function implements the machine independent prelude to a thread context
It is called from only a few distinguished places in the kernel
code as a result of the principle of non-preemptable kernel mode execution.
The various major uses of
can be enumerated as follows:
- From within
when the current thread
voluntarily relinquishes the CPU to wait for some resource to become
- After handling a trap
(e.g. a system call, device interrupt)
when the kernel prepares a return to user-mode execution.
This case is
typically handled by machine dependent trap-handling code after detection
of a change in the signal disposition of the current process, or when a
higher priority thread might be available to run.
The latter event is
communicated by the machine independent scheduling routines by calling
the machine defined
- In the signal handling code
if a signal is delivered that causes a process to stop.
- When a thread dies in
and control of the processor can be passed to the next runnable thread.
where a thread needs to stop execution due to the suspension state of
the process as a whole.
records the amount of time the current thread has been running in the
process structures and checks this value against the CPU time limits
allocated to the process
Exceeding the soft limit results in a
signal to be posted to the process, while exceeding the hard limit will
If the thread is still in the
will put it back onto the run queue, assuming that
it will want to run again soon.
If it is in one of the other
states and KSE threading is enabled, the associated
will be made available to any higher priority threads from the same
group, to allow them to be scheduled next.
After these administrative tasks are done,
hands over control to the machine dependent routine
which will perform the actual thread context switch.
first saves the context of the current thread.
Next, it calls
to determine which thread to run next.
Finally, it reads in the saved context of the new thread and starts to
execute the new thread.
is similar to
except that it does not save the context of the old thread.
This function is useful when the kernel does not have an old thread
context to save, such as when CPUs other than the boot CPU perform their
first task switch, or when the kernel does not care about the state of the
old thread, such as in
when the kernel terminates the current thread and switches into a new
To protect the
all of these functions must be called with the