svcadm(8)을 검색하려면 섹션에서 8 을 선택하고, 맨 페이지 이름에 svcadm을 입력하고 검색을 누른다.
mi_switch(9)
The function implements the machine independent prelude to a
thread context switch. It is called from only a few distin‐
guished 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 a function such as or
when the current thread voluntarily relinquishes the CPU to wait
for some resource or lock to become available. After handling a
trap (e.g. a system call, device interrupt) when the kernel pre‐
pares 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 schedul‐
ing routines by calling the machine defined In the signal han‐
dling code (see 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. In 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 (see Exceeding the
soft limit results in a signal to be posted to the process, while
exceeding the hard limit will cause a If the thread is still in
the state, 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 avail‐
able 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 thread. To
protect the all of these functions must be called with the mutex
held.