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)
277 tsk
->need_resched
= 1;
278 if (tsk
->processor
!= this_cpu
)
279 smp_send_reschedule(tsk
->processor
);
285 int this_cpu
= smp_processor_id();
286 struct task_struct
*tsk
;
288 tsk
= cpu_curr(this_cpu
);
289 if (preemption_goodness(tsk
, p
, this_cpu
) > 1)
290 tsk
->need_resched
= 1;
297 * This has to add the process to the _beginning_ of the
298 * run-queue, not the end. See the comment about "This is
299 * subtle" in the scheduler proper..
301 static inline void add_to_runqueue(struct task_struct
* p
)
303 list_add(&p
->run_list
, &runqueue_head
);
307 static inline void move_last_runqueue(struct task_struct
* p
)
309 list_del(&p
->run_list
);
310 list_add_tail(&p
->run_list
, &runqueue_head
);
313 static inline void move_first_runqueue(struct task_struct
* p
)
315 list_del(&p
->run_list
);
316 list_add(&p
->run_list
, &runqueue_head
);
320 * Wake up a process. Put it on the run-queue if it's not
321 * already there. The "current" process is always on the
322 * run-queue (except when the actual re-schedule is in
323 * progress), and as such you're allowed to do the simpler
324 * "current->state = TASK_RUNNING" to mark yourself runnable
325 * without the overhead of this.
327 inline void wake_up_process(struct task_struct
* p
)
332 * We want the common case fall through straight, thus the goto.
334 spin_lock_irqsave(&runqueue_lock
, flags
);
335 p
->state
= TASK_RUNNING
;
336 if (task_on_runqueue(p
))
341 spin_unlock_irqrestore(&runqueue_lock
, flags
);
344 static inline void wake_up_process_synchronous(struct task_struct
* p
)
349 * We want the common case fall through straight, thus the goto.
351 spin_lock_irqsave(&runqueue_lock
, flags
);
352 p
->state
= TASK_RUNNING
;
353 if (task_on_runqueue(p
))
357 spin_unlock_irqrestore(&runqueue_lock
, flags
);
360 static void process_timeout(unsigned long __data
)
362 struct task_struct
* p
= (struct task_struct
*) __data
;
367 signed long schedule_timeout(signed long timeout
)
369 struct timer_list timer
;
370 unsigned long expire
;
374 case MAX_SCHEDULE_TIMEOUT
:
376 * These two special cases are useful to be comfortable
377 * in the caller. Nothing more. We could take
378 * MAX_SCHEDULE_TIMEOUT from one of the negative value
379 * but I' d like to return a valid offset (>=0) to allow
380 * the caller to do everything it want with the retval.
386 * Another bit of PARANOID. Note that the retval will be
387 * 0 since no piece of kernel is supposed to do a check
388 * for a negative retval of schedule_timeout() (since it
389 * should never happens anyway). You just have the printk()
390 * that will tell you if something is gone wrong and where.
394 printk(KERN_ERR
"schedule_timeout: wrong timeout "
395 "value %lx from %p\n", timeout
,
396 __builtin_return_address(0));
397 current
->state
= TASK_RUNNING
;
402 expire
= timeout
+ jiffies
;
405 timer
.expires
= expire
;
406 timer
.data
= (unsigned long) current
;
407 timer
.function
= process_timeout
;
411 del_timer_sync(&timer
);
413 timeout
= expire
- jiffies
;
416 return timeout
< 0 ? 0 : timeout
;
420 * schedule_tail() is getting called from the fork return path. This
421 * cleans up all remaining scheduler things, without impacting the
424 static inline void __schedule_tail(struct task_struct
*prev
)
430 * prev->policy can be written from here only before `prev'
431 * can be scheduled (before setting prev->has_cpu to zero).
432 * Of course it must also be read before allowing prev
433 * to be rescheduled, but since the write depends on the read
434 * to complete, wmb() is enough. (the spin_lock() acquired
435 * before setting has_cpu is not enough because the spin_lock()
436 * common code semantics allows code outside the critical section
437 * to enter inside the critical section)
439 policy
= prev
->policy
;
440 prev
->policy
= policy
& ~SCHED_YIELD
;
444 * fast path falls through. We have to clear has_cpu before
445 * checking prev->state to avoid a wakeup race - thus we
446 * also have to protect against the task exiting early.
451 if (prev
->state
== TASK_RUNNING
)
459 * Slow path - we 'push' the previous process and
460 * reschedule_idle() will attempt to find a new
461 * processor for it. (but it might preempt the
462 * current process as well.) We must take the runqueue
463 * lock and re-check prev->state to be correct. It might
464 * still happen that this process has a preemption
465 * 'in progress' already - but this is not a problem and
466 * might happen in other circumstances as well.
473 * Avoid taking the runqueue lock in cases where
474 * no preemption-check is necessery:
476 if ((prev
== idle_task(smp_processor_id())) ||
477 (policy
& SCHED_YIELD
))
480 spin_lock_irqsave(&runqueue_lock
, flags
);
481 if (prev
->state
== TASK_RUNNING
)
482 reschedule_idle(prev
);
483 spin_unlock_irqrestore(&runqueue_lock
, flags
);
487 prev
->policy
&= ~SCHED_YIELD
;
488 #endif /* CONFIG_SMP */
491 void schedule_tail(struct task_struct
*prev
)
493 __schedule_tail(prev
);
497 * 'schedule()' is the scheduler function. It's a very simple and nice
498 * scheduler: it's not perfect, but certainly works for most things.
500 * The goto is "interesting".
502 * NOTE!! Task 0 is the 'idle' task, which gets called when no other
503 * tasks can run. It can not be killed, and it cannot sleep. The 'state'
504 * information in task[0] is never used.
506 asmlinkage
void schedule(void)
508 struct schedule_data
* sched_data
;
509 struct task_struct
*prev
, *next
, *p
;
510 struct list_head
*tmp
;
513 if (!current
->active_mm
) BUG();
515 goto handle_tq_scheduler
;
519 this_cpu
= prev
->processor
;
522 goto scheduling_in_interrupt
;
524 release_kernel_lock(prev
, this_cpu
);
526 /* Do "administrative" work here while we don't hold any locks */
527 if (softirq_active(this_cpu
) & softirq_mask(this_cpu
))
532 * 'sched_data' is protected by the fact that we can run
533 * only one process per CPU.
535 sched_data
= & aligned_data
[this_cpu
].schedule_data
;
537 spin_lock_irq(&runqueue_lock
);
539 /* move an exhausted RR process to be last.. */
540 if (prev
->policy
== SCHED_RR
)
544 switch (prev
->state
) {
545 case TASK_INTERRUPTIBLE
:
546 if (signal_pending(prev
)) {
547 prev
->state
= TASK_RUNNING
;
551 del_from_runqueue(prev
);
554 prev
->need_resched
= 0;
557 * this is the scheduler proper:
562 * Default process to select..
564 next
= idle_task(this_cpu
);
566 if (prev
->state
== TASK_RUNNING
)
570 list_for_each(tmp
, &runqueue_head
) {
571 p
= list_entry(tmp
, struct task_struct
, run_list
);
572 if (can_schedule(p
, this_cpu
)) {
573 int weight
= goodness(p
, this_cpu
, prev
->active_mm
);
575 c
= weight
, next
= p
;
579 /* Do we need to re-calculate counters? */
583 * from this point on nothing can prevent us from
584 * switching to the next task, save this fact in
587 sched_data
->curr
= next
;
590 next
->processor
= this_cpu
;
592 spin_unlock_irq(&runqueue_lock
);
599 * maintain the per-process 'last schedule' value.
600 * (this has to be recalculated even if we reschedule to
601 * the same process) Currently this is only used on SMP,
602 * and it's approximate, so we do not have to maintain
603 * it while holding the runqueue spinlock.
605 sched_data
->last_schedule
= get_cycles();
608 * We drop the scheduler lock early (it's a global spinlock),
609 * thus we have to lock the previous process from getting
610 * rescheduled during switch_to().
613 #endif /* CONFIG_SMP */
615 kstat
.context_swtch
++;
617 * there are 3 processes which are affected by a context switch:
619 * prev == .... ==> (last => next)
621 * It's the 'much more previous' 'prev' that is on next's stack,
622 * but prev is set to (the just run) 'last' process by switch_to().
623 * This might sound slightly confusing but makes tons of sense.
627 struct mm_struct
*mm
= next
->mm
;
628 struct mm_struct
*oldmm
= prev
->active_mm
;
630 if (next
->active_mm
) BUG();
631 next
->active_mm
= oldmm
;
632 atomic_inc(&oldmm
->mm_count
);
633 enter_lazy_tlb(oldmm
, next
, this_cpu
);
635 if (next
->active_mm
!= mm
) BUG();
636 switch_mm(oldmm
, mm
, next
, this_cpu
);
640 prev
->active_mm
= NULL
;
646 * This just switches the register state and the
649 switch_to(prev
, next
, prev
);
650 __schedule_tail(prev
);
653 reacquire_kernel_lock(current
);
654 if (current
->need_resched
)
655 goto tq_scheduler_back
;
661 struct task_struct
*p
;
662 spin_unlock_irq(&runqueue_lock
);
663 read_lock(&tasklist_lock
);
665 p
->counter
= (p
->counter
>> 1) + NICE_TO_TICKS(p
->nice
);
666 read_unlock(&tasklist_lock
);
667 spin_lock_irq(&runqueue_lock
);
669 goto repeat_schedule
;
672 c
= goodness(prev
, this_cpu
, prev
->active_mm
);
674 goto still_running_back
;
678 goto handle_softirq_back
;
682 * do not run the task queue with disabled interrupts,
683 * cli() wouldn't work on SMP
686 run_task_queue(&tq_scheduler
);
687 goto tq_scheduler_back
;
690 if (!prev
->counter
) {
691 prev
->counter
= NICE_TO_TICKS(prev
->nice
);
692 move_last_runqueue(prev
);
696 scheduling_in_interrupt
:
697 printk("Scheduling in interrupt\n");
702 static inline void __wake_up_common (wait_queue_head_t
*q
, unsigned int mode
,
703 unsigned int wq_mode
, const int sync
)
705 struct list_head
*tmp
, *head
;
706 struct task_struct
*p
, *best_exclusive
;
713 best_cpu
= smp_processor_id();
714 irq
= in_interrupt();
715 best_exclusive
= NULL
;
716 wq_write_lock_irqsave(&q
->lock
, flags
);
719 CHECK_MAGIC_WQHEAD(q
);
722 head
= &q
->task_list
;
724 if (!head
->next
|| !head
->prev
)
728 while (tmp
!= head
) {
730 wait_queue_t
*curr
= list_entry(tmp
, wait_queue_t
, task_list
);
735 CHECK_MAGIC(curr
->__magic
);
741 curr
->__waker
= (long)__builtin_return_address(0);
744 * If waking up from an interrupt context then
745 * prefer processes which are affine to this
748 if (irq
&& (curr
->flags
& wq_mode
& WQ_FLAG_EXCLUSIVE
)) {
751 if (p
->processor
== best_cpu
) {
757 wake_up_process_synchronous(p
);
760 if (curr
->flags
& wq_mode
& WQ_FLAG_EXCLUSIVE
)
765 if (best_exclusive
) {
767 wake_up_process_synchronous(best_exclusive
);
769 wake_up_process(best_exclusive
);
771 wq_write_unlock_irqrestore(&q
->lock
, flags
);
776 void __wake_up(wait_queue_head_t
*q
, unsigned int mode
, unsigned int wq_mode
)
778 __wake_up_common(q
, mode
, wq_mode
, 0);
781 void __wake_up_sync(wait_queue_head_t
*q
, unsigned int mode
, unsigned int wq_mode
)
783 __wake_up_common(q
, mode
, wq_mode
, 1);
786 #define SLEEP_ON_VAR \
787 unsigned long flags; \
789 init_waitqueue_entry(&wait, current);
791 #define SLEEP_ON_HEAD \
792 wq_write_lock_irqsave(&q->lock,flags); \
793 __add_wait_queue(q, &wait); \
794 wq_write_unlock(&q->lock);
796 #define SLEEP_ON_TAIL \
797 wq_write_lock_irq(&q->lock); \
798 __remove_wait_queue(q, &wait); \
799 wq_write_unlock_irqrestore(&q->lock,flags);
801 void interruptible_sleep_on(wait_queue_head_t
*q
)
805 current
->state
= TASK_INTERRUPTIBLE
;
812 long interruptible_sleep_on_timeout(wait_queue_head_t
*q
, long timeout
)
816 current
->state
= TASK_INTERRUPTIBLE
;
819 timeout
= schedule_timeout(timeout
);
825 void sleep_on(wait_queue_head_t
*q
)
829 current
->state
= TASK_UNINTERRUPTIBLE
;
836 long sleep_on_timeout(wait_queue_head_t
*q
, long timeout
)
840 current
->state
= TASK_UNINTERRUPTIBLE
;
843 timeout
= schedule_timeout(timeout
);
849 void scheduling_functions_end_here(void) { }
854 * This has been replaced by sys_setpriority. Maybe it should be
855 * moved into the arch dependent tree for those ports that require
856 * it for backward compatibility?
859 asmlinkage
long sys_nice(int increment
)
864 * Setpriority might change our priority at the same moment.
865 * We don't have to worry. Conceptually one call occurs first
866 * and we have a single winner.
869 if (!capable(CAP_SYS_NICE
))
877 newprio
= current
->nice
+ increment
;
882 current
->nice
= newprio
;
888 static inline struct task_struct
*find_process_by_pid(pid_t pid
)
890 struct task_struct
*tsk
= current
;
893 tsk
= find_task_by_pid(pid
);
897 static int setscheduler(pid_t pid
, int policy
,
898 struct sched_param
*param
)
900 struct sched_param lp
;
901 struct task_struct
*p
;
905 if (!param
|| pid
< 0)
909 if (copy_from_user(&lp
, param
, sizeof(struct sched_param
)))
913 * We play safe to avoid deadlocks.
915 read_lock_irq(&tasklist_lock
);
916 spin_lock(&runqueue_lock
);
918 p
= find_process_by_pid(pid
);
928 if (policy
!= SCHED_FIFO
&& policy
!= SCHED_RR
&&
929 policy
!= SCHED_OTHER
)
934 * Valid priorities for SCHED_FIFO and SCHED_RR are 1..99, valid
935 * priority for SCHED_OTHER is 0.
938 if (lp
.sched_priority
< 0 || lp
.sched_priority
> 99)
940 if ((policy
== SCHED_OTHER
) != (lp
.sched_priority
== 0))
944 if ((policy
== SCHED_FIFO
|| policy
== SCHED_RR
) &&
945 !capable(CAP_SYS_NICE
))
947 if ((current
->euid
!= p
->euid
) && (current
->euid
!= p
->uid
) &&
948 !capable(CAP_SYS_NICE
))
953 p
->rt_priority
= lp
.sched_priority
;
954 if (task_on_runqueue(p
))
955 move_first_runqueue(p
);
957 current
->need_resched
= 1;
960 spin_unlock(&runqueue_lock
);
961 read_unlock_irq(&tasklist_lock
);
967 asmlinkage
long sys_sched_setscheduler(pid_t pid
, int policy
,
968 struct sched_param
*param
)
970 return setscheduler(pid
, policy
, param
);
973 asmlinkage
long sys_sched_setparam(pid_t pid
, struct sched_param
*param
)
975 return setscheduler(pid
, -1, param
);
978 asmlinkage
long sys_sched_getscheduler(pid_t pid
)
980 struct task_struct
*p
;
988 read_lock(&tasklist_lock
);
989 p
= find_process_by_pid(pid
);
991 retval
= p
->policy
& ~SCHED_YIELD
;
992 read_unlock(&tasklist_lock
);
998 asmlinkage
long sys_sched_getparam(pid_t pid
, struct sched_param
*param
)
1000 struct task_struct
*p
;
1001 struct sched_param lp
;
1005 if (!param
|| pid
< 0)
1008 read_lock(&tasklist_lock
);
1009 p
= find_process_by_pid(pid
);
1013 lp
.sched_priority
= p
->rt_priority
;
1014 read_unlock(&tasklist_lock
);
1017 * This one might sleep, we cannot do it with a spinlock held ...
1019 retval
= copy_to_user(param
, &lp
, sizeof(*param
)) ? -EFAULT
: 0;
1025 read_unlock(&tasklist_lock
);
1029 asmlinkage
long sys_sched_yield(void)
1032 * Trick. sched_yield() first counts the number of truly
1033 * 'pending' runnable processes, then returns if it's
1034 * only the current processes. (This test does not have
1035 * to be atomic.) In threaded applications this optimization
1036 * gets triggered quite often.
1039 int nr_pending
= nr_running
;
1044 // Substract non-idle processes running on other CPUs.
1045 for (i
= 0; i
< smp_num_cpus
; i
++)
1046 if (aligned_data
[i
].schedule_data
.curr
!= idle_task(i
))
1049 // on UP this process is on the runqueue as well
1054 * This process can only be rescheduled by us,
1055 * so this is safe without any locking.
1057 if (current
->policy
== SCHED_OTHER
)
1058 current
->policy
|= SCHED_YIELD
;
1059 current
->need_resched
= 1;
1064 asmlinkage
long sys_sched_get_priority_max(int policy
)
1080 asmlinkage
long sys_sched_get_priority_min(int policy
)
1095 asmlinkage
long sys_sched_rr_get_interval(pid_t pid
, struct timespec
*interval
)
1098 struct task_struct
*p
;
1099 int retval
= -EINVAL
;
1105 read_lock(&tasklist_lock
);
1106 p
= find_process_by_pid(pid
);
1108 jiffies_to_timespec(p
->policy
& SCHED_FIFO
? 0 : NICE_TO_TICKS(p
->nice
),
1110 read_unlock(&tasklist_lock
);
1112 retval
= copy_to_user(interval
, &t
, sizeof(t
)) ? -EFAULT
: 0;
1117 static void show_task(struct task_struct
* p
)
1119 unsigned long free
= 0;
1121 static const char * stat_nam
[] = { "R", "S", "D", "Z", "T", "W" };
1123 printk("%-8s ", p
->comm
);
1124 state
= p
->state
? ffz(~p
->state
) + 1 : 0;
1125 if (((unsigned) state
) < sizeof(stat_nam
)/sizeof(char *))
1126 printk(stat_nam
[state
]);
1129 #if (BITS_PER_LONG == 32)
1131 printk(" current ");
1133 printk(" %08lX ", thread_saved_pc(&p
->thread
));
1136 printk(" current task ");
1138 printk(" %016lx ", thread_saved_pc(&p
->thread
));
1141 unsigned long * n
= (unsigned long *) (p
+1);
1144 free
= (unsigned long) n
- (unsigned long)(p
+1);
1146 printk("%5lu %5d %6d ", free
, p
->pid
, p
->p_pptr
->pid
);
1148 printk("%5d ", p
->p_cptr
->pid
);
1152 printk(" (L-TLB) ");
1154 printk(" (NOTLB) ");
1156 printk("%7d", p
->p_ysptr
->pid
);
1160 printk(" %5d\n", p
->p_osptr
->pid
);
1166 char s
[sizeof(sigset_t
)*2+1], b
[sizeof(sigset_t
)*2+1];
1168 render_sigset_t(&p
->pending
.signal
, s
);
1169 render_sigset_t(&p
->blocked
, b
);
1170 printk(" sig: %d %s %s :", signal_pending(p
), s
, b
);
1171 for (q
= p
->pending
.head
; q
; q
= q
->next
)
1172 printk(" %d", q
->info
.si_signo
);
1177 char * render_sigset_t(sigset_t
*set
, char *buffer
)
1182 if (sigismember(set
, i
+1)) x
|= 1;
1183 if (sigismember(set
, i
+2)) x
|= 2;
1184 if (sigismember(set
, i
+3)) x
|= 4;
1185 if (sigismember(set
, i
+4)) x
|= 8;
1186 *buffer
++ = (x
< 10 ? '0' : 'a' - 10) + x
;
1192 void show_state(void)
1194 struct task_struct
*p
;
1196 #if (BITS_PER_LONG == 32)
1199 printk(" task PC stack pid father child younger older\n");
1203 printk(" task PC stack pid father child younger older\n");
1205 read_lock(&tasklist_lock
);
1208 read_unlock(&tasklist_lock
);
1212 * Put all the gunge required to become a kernel thread without
1213 * attached user resources in one place where it belongs.
1216 void daemonize(void)
1218 struct fs_struct
*fs
;
1222 * If we were started as result of loading a module, close all of the
1223 * user space pages. We don't need them, and if we didn't close them
1224 * they would be locked into memory.
1228 current
->session
= 1;
1231 /* Become as one with the init task */
1233 exit_fs(current
); /* current->fs->count--; */
1236 atomic_inc(&fs
->count
);
1237 exit_files(current
);
1238 current
->files
= init_task
.files
;
1239 atomic_inc(¤t
->files
->count
);
1242 void __init
init_idle(void)
1244 struct schedule_data
* sched_data
;
1245 sched_data
= &aligned_data
[smp_processor_id()].schedule_data
;
1247 if (current
!= &init_task
&& task_on_runqueue(current
)) {
1248 printk("UGH! (%d:%d) was on the runqueue, removing.\n",
1249 smp_processor_id(), current
->pid
);
1250 del_from_runqueue(current
);
1252 sched_data
->curr
= current
;
1253 sched_data
->last_schedule
= get_cycles();
1256 extern void init_timervecs (void);
1258 void __init
sched_init(void)
1261 * We have to do a little magic to get the first
1262 * process right in SMP mode.
1264 int cpu
= smp_processor_id();
1267 init_task
.processor
= cpu
;
1269 for(nr
= 0; nr
< PIDHASH_SZ
; nr
++)
1274 init_bh(TIMER_BH
, timer_bh
);
1275 init_bh(TQUEUE_BH
, tqueue_bh
);
1276 init_bh(IMMEDIATE_BH
, immediate_bh
);
1279 * The boot idle thread does lazy MMU switching as well:
1281 atomic_inc(&init_mm
.mm_count
);
1282 enter_lazy_tlb(&init_mm
, current
, cpu
);