4 * Kernel scheduler and related syscalls
6 * Copyright (C) 1991, 1992 Linus Torvalds
8 * 1996-12-23 Modified by Dave Grothe to fix bugs in semaphores and
9 * make semaphores SMP safe
10 * 1998-11-19 Implemented schedule_timeout() and related stuff
12 * 1998-12-28 Implemented better SMP scheduling by Ingo Molnar
16 * 'sched.c' is the main kernel file. It contains scheduling primitives
17 * (sleep_on, wakeup, schedule etc) as well as a number of simple system
18 * call functions (type getpid()), which just extract a field from
22 #include <linux/config.h>
24 #include <linux/init.h>
25 #include <linux/smp_lock.h>
26 #include <linux/interrupt.h>
27 #include <linux/kernel_stat.h>
29 #include <asm/uaccess.h>
30 #include <asm/mmu_context.h>
32 extern void timer_bh(void);
33 extern void tqueue_bh(void);
34 extern void immediate_bh(void);
40 unsigned securebits
= SECUREBITS_DEFAULT
; /* systemwide security settings */
42 extern void mem_use(void);
47 * NOTE! The unix "nice" value influences how long a process
48 * gets. The nice value ranges from -20 to +19, where a -20
49 * is a "high-priority" task, and a "+10" is a low-priority
52 * We want the time-slice to be around 50ms or so, so this
53 * calculation depends on the value of HZ.
56 #define TICK_SCALE(x) ((x) >> 2)
58 #define TICK_SCALE(x) ((x) >> 1)
60 #define TICK_SCALE(x) (x)
62 #define TICK_SCALE(x) ((x) << 1)
64 #define TICK_SCALE(x) ((x) << 2)
67 #define NICE_TO_TICKS(nice) (TICK_SCALE(20-(nice))+1)
71 * Init task must be ok at boot for the ix86 as we will check its signals
72 * via the SMP irq return path.
75 struct task_struct
* init_tasks
[NR_CPUS
] = {&init_task
, };
78 * The tasklist_lock protects the linked list of processes.
80 * The runqueue_lock locks the parts that actually access
81 * and change the run-queues, and have to be interrupt-safe.
83 * If both locks are to be concurrently held, the runqueue_lock
84 * nests inside the tasklist_lock.
86 spinlock_t runqueue_lock __cacheline_aligned
= SPIN_LOCK_UNLOCKED
; /* inner */
87 rwlock_t tasklist_lock __cacheline_aligned
= RW_LOCK_UNLOCKED
; /* outer */
89 static LIST_HEAD(runqueue_head
);
92 * We align per-CPU scheduling data on cacheline boundaries,
93 * to prevent cacheline ping-pong.
96 struct schedule_data
{
97 struct task_struct
* curr
;
98 cycles_t last_schedule
;
100 char __pad
[SMP_CACHE_BYTES
];
101 } aligned_data
[NR_CPUS
] __cacheline_aligned
= { {{&init_task
,0}}};
103 #define cpu_curr(cpu) aligned_data[(cpu)].schedule_data.curr
104 #define last_schedule(cpu) aligned_data[(cpu)].schedule_data.last_schedule
106 struct kernel_stat kstat
;
110 #define idle_task(cpu) (init_tasks[cpu_number_map(cpu)])
111 #define can_schedule(p,cpu) ((!(p)->has_cpu) && \
112 ((p)->cpus_allowed & (1 << cpu)))
116 #define idle_task(cpu) (&init_task)
117 #define can_schedule(p,cpu) (1)
121 void scheduling_functions_start_here(void) { }
124 * This is the function that decides how desirable a process is..
125 * You can weigh different processes against each other depending
126 * on what CPU they've run on lately etc to try to handle cache
127 * and TLB miss penalties.
130 * -1000: never select this
131 * 0: out of time, recalculate counters (but it might still be
133 * +ve: "goodness" value (the larger, the better)
134 * +1000: realtime process, select this.
137 static inline int goodness(struct task_struct
* p
, int this_cpu
, struct mm_struct
*this_mm
)
142 * select the current process after every other
143 * runnable process, but before the idle thread.
144 * Also, dont trigger a counter recalculation.
147 if (p
->policy
& SCHED_YIELD
)
151 * Non-RT process - normal case first.
153 if (p
->policy
== SCHED_OTHER
) {
155 * Give the process a first-approximation goodness value
156 * according to the number of clock-ticks it has left.
158 * Don't do any other calculations if the time slice is
166 /* Give a largish advantage to the same processor... */
167 /* (this is equivalent to penalizing other processors) */
168 if (p
->processor
== this_cpu
)
169 weight
+= PROC_CHANGE_PENALTY
;
172 /* .. and a slight advantage to the current MM */
173 if (p
->mm
== this_mm
|| !p
->mm
)
175 weight
+= 20 - p
->nice
;
180 * Realtime process, select the first one on the
181 * runqueue (taking priorities within processes
184 weight
= 1000 + p
->rt_priority
;
190 * the 'goodness value' of replacing a process on a given CPU.
191 * positive value means 'replace', zero or negative means 'dont'.
193 static inline int preemption_goodness(struct task_struct
* prev
, struct task_struct
* p
, int cpu
)
195 return goodness(p
, cpu
, prev
->active_mm
) - goodness(prev
, cpu
, prev
->active_mm
);
199 * This is ugly, but reschedule_idle() is very timing-critical.
200 * We are called with the runqueue spinlock held and we must
201 * not claim the tasklist_lock.
203 static FASTCALL(void reschedule_idle(struct task_struct
* p
));
205 static void reschedule_idle(struct task_struct
* p
)
208 int this_cpu
= smp_processor_id();
209 struct task_struct
*tsk
, *target_tsk
;
210 int cpu
, best_cpu
, i
, max_prio
;
211 cycles_t oldest_idle
;
214 * shortcut if the woken up task's last CPU is
217 best_cpu
= p
->processor
;
218 if (can_schedule(p
, best_cpu
)) {
219 tsk
= idle_task(best_cpu
);
220 if (cpu_curr(best_cpu
) == tsk
) {
224 * If need_resched == -1 then we can skip sending
225 * the IPI altogether, tsk->need_resched is
226 * actively watched by the idle thread.
228 need_resched
= tsk
->need_resched
;
229 tsk
->need_resched
= 1;
230 if ((best_cpu
!= this_cpu
) && !need_resched
)
231 smp_send_reschedule(best_cpu
);
237 * We know that the preferred CPU has a cache-affine current
238 * process, lets try to find a new idle CPU for the woken-up
239 * process. Select the least recently active idle CPU. (that
240 * one will have the least active cache context.) Also find
241 * the executing process which has the least priority.
243 oldest_idle
= (cycles_t
) -1;
247 for (i
= 0; i
< smp_num_cpus
; i
++) {
248 cpu
= cpu_logical_map(i
);
249 if (!can_schedule(p
, cpu
))
253 * We use the first available idle CPU. This creates
254 * a priority list between idle CPUs, but this is not
257 if (tsk
== idle_task(cpu
)) {
258 if (last_schedule(cpu
) < oldest_idle
) {
259 oldest_idle
= last_schedule(cpu
);
263 if (oldest_idle
== -1ULL) {
264 int prio
= preemption_goodness(tsk
, p
, cpu
);
266 if (prio
> max_prio
) {
275 if (oldest_idle
!= -1ULL) {
276 best_cpu
= tsk
->processor
;
279 tsk
->need_resched
= 1;
280 if (tsk
->processor
!= this_cpu
)
281 smp_send_reschedule(tsk
->processor
);
287 int this_cpu
= smp_processor_id();
288 struct task_struct
*tsk
;
290 tsk
= cpu_curr(this_cpu
);
291 if (preemption_goodness(tsk
, p
, this_cpu
) > 1)
292 tsk
->need_resched
= 1;
299 * This has to add the process to the _beginning_ of the
300 * run-queue, not the end. See the comment about "This is
301 * subtle" in the scheduler proper..
303 static inline void add_to_runqueue(struct task_struct
* p
)
305 list_add(&p
->run_list
, &runqueue_head
);
309 static inline void move_last_runqueue(struct task_struct
* p
)
311 list_del(&p
->run_list
);
312 list_add_tail(&p
->run_list
, &runqueue_head
);
315 static inline void move_first_runqueue(struct task_struct
* p
)
317 list_del(&p
->run_list
);
318 list_add(&p
->run_list
, &runqueue_head
);
322 * Wake up a process. Put it on the run-queue if it's not
323 * already there. The "current" process is always on the
324 * run-queue (except when the actual re-schedule is in
325 * progress), and as such you're allowed to do the simpler
326 * "current->state = TASK_RUNNING" to mark yourself runnable
327 * without the overhead of this.
329 inline void wake_up_process(struct task_struct
* p
)
334 * We want the common case fall through straight, thus the goto.
336 spin_lock_irqsave(&runqueue_lock
, flags
);
337 p
->state
= TASK_RUNNING
;
338 if (task_on_runqueue(p
))
343 spin_unlock_irqrestore(&runqueue_lock
, flags
);
346 static inline void wake_up_process_synchronous(struct task_struct
* p
)
351 * We want the common case fall through straight, thus the goto.
353 spin_lock_irqsave(&runqueue_lock
, flags
);
354 p
->state
= TASK_RUNNING
;
355 if (task_on_runqueue(p
))
359 spin_unlock_irqrestore(&runqueue_lock
, flags
);
362 static void process_timeout(unsigned long __data
)
364 struct task_struct
* p
= (struct task_struct
*) __data
;
369 signed long schedule_timeout(signed long timeout
)
371 struct timer_list timer
;
372 unsigned long expire
;
376 case MAX_SCHEDULE_TIMEOUT
:
378 * These two special cases are useful to be comfortable
379 * in the caller. Nothing more. We could take
380 * MAX_SCHEDULE_TIMEOUT from one of the negative value
381 * but I' d like to return a valid offset (>=0) to allow
382 * the caller to do everything it want with the retval.
388 * Another bit of PARANOID. Note that the retval will be
389 * 0 since no piece of kernel is supposed to do a check
390 * for a negative retval of schedule_timeout() (since it
391 * should never happens anyway). You just have the printk()
392 * that will tell you if something is gone wrong and where.
396 printk(KERN_ERR
"schedule_timeout: wrong timeout "
397 "value %lx from %p\n", timeout
,
398 __builtin_return_address(0));
399 current
->state
= TASK_RUNNING
;
404 expire
= timeout
+ jiffies
;
407 timer
.expires
= expire
;
408 timer
.data
= (unsigned long) current
;
409 timer
.function
= process_timeout
;
413 del_timer_sync(&timer
);
415 timeout
= expire
- jiffies
;
418 return timeout
< 0 ? 0 : timeout
;
422 * schedule_tail() is getting called from the fork return path. This
423 * cleans up all remaining scheduler things, without impacting the
426 static inline void __schedule_tail(struct task_struct
*prev
)
432 * prev->policy can be written from here only before `prev'
433 * can be scheduled (before setting prev->has_cpu to zero).
434 * Of course it must also be read before allowing prev
435 * to be rescheduled, but since the write depends on the read
436 * to complete, wmb() is enough. (the spin_lock() acquired
437 * before setting has_cpu is not enough because the spin_lock()
438 * common code semantics allows code outside the critical section
439 * to enter inside the critical section)
441 policy
= prev
->policy
;
442 prev
->policy
= policy
& ~SCHED_YIELD
;
446 * fast path falls through. We have to clear has_cpu before
447 * checking prev->state to avoid a wakeup race - thus we
448 * also have to protect against the task exiting early.
453 if (prev
->state
== TASK_RUNNING
)
457 task_unlock(prev
); /* Synchronise here with release_task() if prev is TASK_ZOMBIE */
461 * Slow path - we 'push' the previous process and
462 * reschedule_idle() will attempt to find a new
463 * processor for it. (but it might preempt the
464 * current process as well.) We must take the runqueue
465 * lock and re-check prev->state to be correct. It might
466 * still happen that this process has a preemption
467 * 'in progress' already - but this is not a problem and
468 * might happen in other circumstances as well.
475 * Avoid taking the runqueue lock in cases where
476 * no preemption-check is necessery:
478 if ((prev
== idle_task(smp_processor_id())) ||
479 (policy
& SCHED_YIELD
))
482 spin_lock_irqsave(&runqueue_lock
, flags
);
483 if (prev
->state
== TASK_RUNNING
)
484 reschedule_idle(prev
);
485 spin_unlock_irqrestore(&runqueue_lock
, flags
);
489 prev
->policy
&= ~SCHED_YIELD
;
490 #endif /* CONFIG_SMP */
493 void schedule_tail(struct task_struct
*prev
)
495 __schedule_tail(prev
);
499 * 'schedule()' is the scheduler function. It's a very simple and nice
500 * scheduler: it's not perfect, but certainly works for most things.
502 * The goto is "interesting".
504 * NOTE!! Task 0 is the 'idle' task, which gets called when no other
505 * tasks can run. It can not be killed, and it cannot sleep. The 'state'
506 * information in task[0] is never used.
508 asmlinkage
void schedule(void)
510 struct schedule_data
* sched_data
;
511 struct task_struct
*prev
, *next
, *p
;
512 struct list_head
*tmp
;
515 if (!current
->active_mm
) BUG();
517 goto handle_tq_scheduler
;
521 this_cpu
= prev
->processor
;
524 goto scheduling_in_interrupt
;
526 release_kernel_lock(prev
, this_cpu
);
528 /* Do "administrative" work here while we don't hold any locks */
529 if (softirq_active(this_cpu
) & softirq_mask(this_cpu
))
534 * 'sched_data' is protected by the fact that we can run
535 * only one process per CPU.
537 sched_data
= & aligned_data
[this_cpu
].schedule_data
;
539 spin_lock_irq(&runqueue_lock
);
541 /* move an exhausted RR process to be last.. */
542 if (prev
->policy
== SCHED_RR
)
546 switch (prev
->state
) {
547 case TASK_INTERRUPTIBLE
:
548 if (signal_pending(prev
)) {
549 prev
->state
= TASK_RUNNING
;
553 del_from_runqueue(prev
);
556 prev
->need_resched
= 0;
559 * this is the scheduler proper:
564 * Default process to select..
566 next
= idle_task(this_cpu
);
568 if (prev
->state
== TASK_RUNNING
)
572 list_for_each(tmp
, &runqueue_head
) {
573 p
= list_entry(tmp
, struct task_struct
, run_list
);
574 if (can_schedule(p
, this_cpu
)) {
575 int weight
= goodness(p
, this_cpu
, prev
->active_mm
);
577 c
= weight
, next
= p
;
581 /* Do we need to re-calculate counters? */
585 * from this point on nothing can prevent us from
586 * switching to the next task, save this fact in
589 sched_data
->curr
= next
;
592 next
->processor
= this_cpu
;
594 spin_unlock_irq(&runqueue_lock
);
601 * maintain the per-process 'last schedule' value.
602 * (this has to be recalculated even if we reschedule to
603 * the same process) Currently this is only used on SMP,
604 * and it's approximate, so we do not have to maintain
605 * it while holding the runqueue spinlock.
607 sched_data
->last_schedule
= get_cycles();
610 * We drop the scheduler lock early (it's a global spinlock),
611 * thus we have to lock the previous process from getting
612 * rescheduled during switch_to().
615 #endif /* CONFIG_SMP */
617 kstat
.context_swtch
++;
619 * there are 3 processes which are affected by a context switch:
621 * prev == .... ==> (last => next)
623 * It's the 'much more previous' 'prev' that is on next's stack,
624 * but prev is set to (the just run) 'last' process by switch_to().
625 * This might sound slightly confusing but makes tons of sense.
629 struct mm_struct
*mm
= next
->mm
;
630 struct mm_struct
*oldmm
= prev
->active_mm
;
632 if (next
->active_mm
) BUG();
633 next
->active_mm
= oldmm
;
634 atomic_inc(&oldmm
->mm_count
);
635 enter_lazy_tlb(oldmm
, next
, this_cpu
);
637 if (next
->active_mm
!= mm
) BUG();
638 switch_mm(oldmm
, mm
, next
, this_cpu
);
642 prev
->active_mm
= NULL
;
648 * This just switches the register state and the
651 switch_to(prev
, next
, prev
);
652 __schedule_tail(prev
);
655 reacquire_kernel_lock(current
);
656 if (current
->need_resched
)
657 goto tq_scheduler_back
;
663 struct task_struct
*p
;
664 spin_unlock_irq(&runqueue_lock
);
665 read_lock(&tasklist_lock
);
667 p
->counter
= (p
->counter
>> 1) + NICE_TO_TICKS(p
->nice
);
668 read_unlock(&tasklist_lock
);
669 spin_lock_irq(&runqueue_lock
);
671 goto repeat_schedule
;
674 c
= goodness(prev
, this_cpu
, prev
->active_mm
);
676 goto still_running_back
;
680 goto handle_softirq_back
;
684 * do not run the task queue with disabled interrupts,
685 * cli() wouldn't work on SMP
688 run_task_queue(&tq_scheduler
);
689 goto tq_scheduler_back
;
692 if (!prev
->counter
) {
693 prev
->counter
= NICE_TO_TICKS(prev
->nice
);
694 move_last_runqueue(prev
);
698 scheduling_in_interrupt
:
699 printk("Scheduling in interrupt\n");
704 static inline void __wake_up_common (wait_queue_head_t
*q
, unsigned int mode
,
705 unsigned int wq_mode
, const int sync
)
707 struct list_head
*tmp
, *head
;
708 struct task_struct
*p
, *best_exclusive
;
715 best_cpu
= smp_processor_id();
716 irq
= in_interrupt();
717 best_exclusive
= NULL
;
718 wq_write_lock_irqsave(&q
->lock
, flags
);
721 CHECK_MAGIC_WQHEAD(q
);
724 head
= &q
->task_list
;
726 if (!head
->next
|| !head
->prev
)
730 while (tmp
!= head
) {
732 wait_queue_t
*curr
= list_entry(tmp
, wait_queue_t
, task_list
);
737 CHECK_MAGIC(curr
->__magic
);
743 curr
->__waker
= (long)__builtin_return_address(0);
746 * If waking up from an interrupt context then
747 * prefer processes which are affine to this
750 if (irq
&& (curr
->flags
& wq_mode
& WQ_FLAG_EXCLUSIVE
)) {
753 if (p
->processor
== best_cpu
) {
759 wake_up_process_synchronous(p
);
762 if (curr
->flags
& wq_mode
& WQ_FLAG_EXCLUSIVE
)
767 if (best_exclusive
) {
769 wake_up_process_synchronous(best_exclusive
);
771 wake_up_process(best_exclusive
);
773 wq_write_unlock_irqrestore(&q
->lock
, flags
);
778 void __wake_up(wait_queue_head_t
*q
, unsigned int mode
, unsigned int wq_mode
)
780 __wake_up_common(q
, mode
, wq_mode
, 0);
783 void __wake_up_sync(wait_queue_head_t
*q
, unsigned int mode
, unsigned int wq_mode
)
785 __wake_up_common(q
, mode
, wq_mode
, 1);
788 #define SLEEP_ON_VAR \
789 unsigned long flags; \
791 init_waitqueue_entry(&wait, current);
793 #define SLEEP_ON_HEAD \
794 wq_write_lock_irqsave(&q->lock,flags); \
795 __add_wait_queue(q, &wait); \
796 wq_write_unlock(&q->lock);
798 #define SLEEP_ON_TAIL \
799 wq_write_lock_irq(&q->lock); \
800 __remove_wait_queue(q, &wait); \
801 wq_write_unlock_irqrestore(&q->lock,flags);
803 void interruptible_sleep_on(wait_queue_head_t
*q
)
807 current
->state
= TASK_INTERRUPTIBLE
;
814 long interruptible_sleep_on_timeout(wait_queue_head_t
*q
, long timeout
)
818 current
->state
= TASK_INTERRUPTIBLE
;
821 timeout
= schedule_timeout(timeout
);
827 void sleep_on(wait_queue_head_t
*q
)
831 current
->state
= TASK_UNINTERRUPTIBLE
;
838 long sleep_on_timeout(wait_queue_head_t
*q
, long timeout
)
842 current
->state
= TASK_UNINTERRUPTIBLE
;
845 timeout
= schedule_timeout(timeout
);
851 void scheduling_functions_end_here(void) { }
856 * This has been replaced by sys_setpriority. Maybe it should be
857 * moved into the arch dependent tree for those ports that require
858 * it for backward compatibility?
861 asmlinkage
long sys_nice(int increment
)
866 * Setpriority might change our priority at the same moment.
867 * We don't have to worry. Conceptually one call occurs first
868 * and we have a single winner.
871 if (!capable(CAP_SYS_NICE
))
879 newprio
= current
->nice
+ increment
;
884 current
->nice
= newprio
;
890 static inline struct task_struct
*find_process_by_pid(pid_t pid
)
892 struct task_struct
*tsk
= current
;
895 tsk
= find_task_by_pid(pid
);
899 static int setscheduler(pid_t pid
, int policy
,
900 struct sched_param
*param
)
902 struct sched_param lp
;
903 struct task_struct
*p
;
907 if (!param
|| pid
< 0)
911 if (copy_from_user(&lp
, param
, sizeof(struct sched_param
)))
915 * We play safe to avoid deadlocks.
917 read_lock_irq(&tasklist_lock
);
918 spin_lock(&runqueue_lock
);
920 p
= find_process_by_pid(pid
);
930 if (policy
!= SCHED_FIFO
&& policy
!= SCHED_RR
&&
931 policy
!= SCHED_OTHER
)
936 * Valid priorities for SCHED_FIFO and SCHED_RR are 1..99, valid
937 * priority for SCHED_OTHER is 0.
940 if (lp
.sched_priority
< 0 || lp
.sched_priority
> 99)
942 if ((policy
== SCHED_OTHER
) != (lp
.sched_priority
== 0))
946 if ((policy
== SCHED_FIFO
|| policy
== SCHED_RR
) &&
947 !capable(CAP_SYS_NICE
))
949 if ((current
->euid
!= p
->euid
) && (current
->euid
!= p
->uid
) &&
950 !capable(CAP_SYS_NICE
))
955 p
->rt_priority
= lp
.sched_priority
;
956 if (task_on_runqueue(p
))
957 move_first_runqueue(p
);
959 current
->need_resched
= 1;
962 spin_unlock(&runqueue_lock
);
963 read_unlock_irq(&tasklist_lock
);
969 asmlinkage
long sys_sched_setscheduler(pid_t pid
, int policy
,
970 struct sched_param
*param
)
972 return setscheduler(pid
, policy
, param
);
975 asmlinkage
long sys_sched_setparam(pid_t pid
, struct sched_param
*param
)
977 return setscheduler(pid
, -1, param
);
980 asmlinkage
long sys_sched_getscheduler(pid_t pid
)
982 struct task_struct
*p
;
990 read_lock(&tasklist_lock
);
991 p
= find_process_by_pid(pid
);
993 retval
= p
->policy
& ~SCHED_YIELD
;
994 read_unlock(&tasklist_lock
);
1000 asmlinkage
long sys_sched_getparam(pid_t pid
, struct sched_param
*param
)
1002 struct task_struct
*p
;
1003 struct sched_param lp
;
1007 if (!param
|| pid
< 0)
1010 read_lock(&tasklist_lock
);
1011 p
= find_process_by_pid(pid
);
1015 lp
.sched_priority
= p
->rt_priority
;
1016 read_unlock(&tasklist_lock
);
1019 * This one might sleep, we cannot do it with a spinlock held ...
1021 retval
= copy_to_user(param
, &lp
, sizeof(*param
)) ? -EFAULT
: 0;
1027 read_unlock(&tasklist_lock
);
1031 asmlinkage
long sys_sched_yield(void)
1034 * Trick. sched_yield() first counts the number of truly
1035 * 'pending' runnable processes, then returns if it's
1036 * only the current processes. (This test does not have
1037 * to be atomic.) In threaded applications this optimization
1038 * gets triggered quite often.
1041 int nr_pending
= nr_running
;
1046 // Substract non-idle processes running on other CPUs.
1047 for (i
= 0; i
< smp_num_cpus
; i
++)
1048 if (aligned_data
[i
].schedule_data
.curr
!= idle_task(i
))
1051 // on UP this process is on the runqueue as well
1056 * This process can only be rescheduled by us,
1057 * so this is safe without any locking.
1059 if (current
->policy
== SCHED_OTHER
)
1060 current
->policy
|= SCHED_YIELD
;
1061 current
->need_resched
= 1;
1066 asmlinkage
long sys_sched_get_priority_max(int policy
)
1082 asmlinkage
long sys_sched_get_priority_min(int policy
)
1097 asmlinkage
long sys_sched_rr_get_interval(pid_t pid
, struct timespec
*interval
)
1100 struct task_struct
*p
;
1101 int retval
= -EINVAL
;
1107 read_lock(&tasklist_lock
);
1108 p
= find_process_by_pid(pid
);
1110 jiffies_to_timespec(p
->policy
& SCHED_FIFO
? 0 : NICE_TO_TICKS(p
->nice
),
1112 read_unlock(&tasklist_lock
);
1114 retval
= copy_to_user(interval
, &t
, sizeof(t
)) ? -EFAULT
: 0;
1119 static void show_task(struct task_struct
* p
)
1121 unsigned long free
= 0;
1123 static const char * stat_nam
[] = { "R", "S", "D", "Z", "T", "W" };
1125 printk("%-8s ", p
->comm
);
1126 state
= p
->state
? ffz(~p
->state
) + 1 : 0;
1127 if (((unsigned) state
) < sizeof(stat_nam
)/sizeof(char *))
1128 printk(stat_nam
[state
]);
1131 #if (BITS_PER_LONG == 32)
1133 printk(" current ");
1135 printk(" %08lX ", thread_saved_pc(&p
->thread
));
1138 printk(" current task ");
1140 printk(" %016lx ", thread_saved_pc(&p
->thread
));
1143 unsigned long * n
= (unsigned long *) (p
+1);
1146 free
= (unsigned long) n
- (unsigned long)(p
+1);
1148 printk("%5lu %5d %6d ", free
, p
->pid
, p
->p_pptr
->pid
);
1150 printk("%5d ", p
->p_cptr
->pid
);
1154 printk(" (L-TLB) ");
1156 printk(" (NOTLB) ");
1158 printk("%7d", p
->p_ysptr
->pid
);
1162 printk(" %5d\n", p
->p_osptr
->pid
);
1168 char s
[sizeof(sigset_t
)*2+1], b
[sizeof(sigset_t
)*2+1];
1170 render_sigset_t(&p
->pending
.signal
, s
);
1171 render_sigset_t(&p
->blocked
, b
);
1172 printk(" sig: %d %s %s :", signal_pending(p
), s
, b
);
1173 for (q
= p
->pending
.head
; q
; q
= q
->next
)
1174 printk(" %d", q
->info
.si_signo
);
1179 char * render_sigset_t(sigset_t
*set
, char *buffer
)
1184 if (sigismember(set
, i
+1)) x
|= 1;
1185 if (sigismember(set
, i
+2)) x
|= 2;
1186 if (sigismember(set
, i
+3)) x
|= 4;
1187 if (sigismember(set
, i
+4)) x
|= 8;
1188 *buffer
++ = (x
< 10 ? '0' : 'a' - 10) + x
;
1194 void show_state(void)
1196 struct task_struct
*p
;
1198 #if (BITS_PER_LONG == 32)
1201 printk(" task PC stack pid father child younger older\n");
1205 printk(" task PC stack pid father child younger older\n");
1207 read_lock(&tasklist_lock
);
1210 read_unlock(&tasklist_lock
);
1214 * Put all the gunge required to become a kernel thread without
1215 * attached user resources in one place where it belongs.
1218 void daemonize(void)
1220 struct fs_struct
*fs
;
1224 * If we were started as result of loading a module, close all of the
1225 * user space pages. We don't need them, and if we didn't close them
1226 * they would be locked into memory.
1230 current
->session
= 1;
1233 /* Become as one with the init task */
1235 exit_fs(current
); /* current->fs->count--; */
1238 atomic_inc(&fs
->count
);
1239 exit_files(current
);
1240 current
->files
= init_task
.files
;
1241 atomic_inc(¤t
->files
->count
);
1244 void __init
init_idle(void)
1246 struct schedule_data
* sched_data
;
1247 sched_data
= &aligned_data
[smp_processor_id()].schedule_data
;
1249 if (current
!= &init_task
&& task_on_runqueue(current
)) {
1250 printk("UGH! (%d:%d) was on the runqueue, removing.\n",
1251 smp_processor_id(), current
->pid
);
1252 del_from_runqueue(current
);
1254 sched_data
->curr
= current
;
1255 sched_data
->last_schedule
= get_cycles();
1258 extern void init_timervecs (void);
1260 void __init
sched_init(void)
1263 * We have to do a little magic to get the first
1264 * process right in SMP mode.
1266 int cpu
= smp_processor_id();
1269 init_task
.processor
= cpu
;
1271 for(nr
= 0; nr
< PIDHASH_SZ
; nr
++)
1276 init_bh(TIMER_BH
, timer_bh
);
1277 init_bh(TQUEUE_BH
, tqueue_bh
);
1278 init_bh(IMMEDIATE_BH
, immediate_bh
);
1281 * The boot idle thread does lazy MMU switching as well:
1283 atomic_inc(&init_mm
.mm_count
);
1284 enter_lazy_tlb(&init_mm
, current
, cpu
);