Terminating a process -- Transition from allproc list to zombieproc list

How does a process get terminated? Lets say a process has three threads A,B & C. Now when we send a SIG_KILL signal to the process. All is fine so far, Now each process has exit status field in its structure! So, when a process is sent a kill signal, my understanding is that it is sent to all the threads. A thread gets killed either when it traps into kernel. If it is alreading in the kernel, it quits when it exits from the kernel. If a thread is sleeping it exits when it wakes up. Is my understanding right or am i misunderstadin开发者_StackOverflow中文版g/missing something?

If my understanding is correct, when is a process put into zombie list? when all the threads exited or as soon as it receives a kill signal?

Lets say a process has three threads A,B & C.

Ok. I assume modern Linux, with kernel supporting threads (Linux 2.6 + glibc > 2.3)

Then the process (or thread group) consists of 3 threads (or, there is a 3 threads with different tids and same tgid=PID)

Now when we send a SIG_KILL signal to the process.

So, you use a tgid (PID) here. Ok.

Now each process has exit status field in its structure!

Wwwhat? Yes, but killing and exiting from thread group have a special code to get right exit code to waiter. For killing, the exit status is get from signal; for exiting (syscall sys_group_exit) it is the argument of syscall.

So, when a process is sent a kill signal,... it is sent to all the threads.

No.

Basically there can be two kinds of signals:

1. process-wide - it will be delivered to ANY thread in the process
2. thread (Can't name it correctly) - which is delivered by tid to some thread and not another.

So, SIGKILL is process-wide, it will kill entire process. It is delivered to some thread.

When kernel will deliver this signal - it will call do_group_exit() function ( http://lxr.linux.no/linux+v2.6.28/kernel/exit.c#L1156 called from http://lxr.linux.no/linux+v2.6.28/kernel/signal.c#L1870) to kill all threads in thread group (in process).

There is a zap_other_threads() function to iterate over all threads and kill them (with resending a thread-delivered SIGKILL) http://lxr.linux.no/linux+v2.6.28/kernel/signal.c#L966

when is a process put into zombie list?

After do_exit() kernel function call. It has a tsk->state = TASK_DEAD; line at the end.

when all the threads exited or as soon as it receives a kill signal?

The moment, when task get its state to TASK_DEAD is after receiving SIGKILL. This signal is already redelivered to all threads of the process at this moment. Can't find the actual exit time of threads, but all threads have a flag of pending fatal signal, so they will be killed at any resched.

UPDATE: all threads of process must be killed (must receive the KILL signal and do a cleanup), as they have some accounting information to be accumulated in the first thread (here first mention not the first-started, but the thread which got an original process-wide SIGKILL; or the thread, which called an exit_group syscall). First thread must wait all another threads; and it will change status only after that.

In FreeBSD, a zombie process cannot execute any code. Therefore, everything that needs the moribund process to do something is performed before that point. If you see a process in this state in ps(1) (usually only if it gets stuck), it has a usual state such as D, S, R or I, with E (trying to exit) appended to it.

A signal is delivered to one thread (either a particular thread or any thread, depending on how the signal was generated). The act of terminating the process (default action of various signals) has a process-global effect. One of the things that happens is that the thread that was chosen to deliver the signal (or that called _exit(2)) requests all other threads to exit.

A thread does not have an exit status at the kernel level; the value available via pthread_join() is a userland feature.