Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71f11dc0 authored by Oleg Nesterov's avatar Oleg Nesterov Committed by Linus Torvalds
Browse files

signals: move the definition of __group_complete_signal() up 



Move the unchanged definition of __group_complete_signal() so that send_signal
can see it.  To simplify the reading of the next patches.

Signed-off-by: default avatarOleg Nesterov <oleg@tv-sign.ru>
Cc: Roland McGrath <roland@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent db51aecc

kernel/signal.c

+96 −96
Original line number Diff line number Diff line
@@ -652,6 +652,102 @@ static void handle_stop_signal(int sig, struct task_struct *p) 
	}

}



/*

 * Test if P wants to take SIG.  After we've checked all threads with this,

 * it's equivalent to finding no threads not blocking SIG.  Any threads not

 * blocking SIG were ruled out because they are not running and already

 * have pending signals.  Such threads will dequeue from the shared queue

 * as soon as they're available, so putting the signal on the shared queue

 * will be equivalent to sending it to one such thread.

 */

static inline int wants_signal(int sig, struct task_struct *p)

{

	if (sigismember(&p->blocked, sig))

		return 0;

	if (p->flags & PF_EXITING)

		return 0;

	if (sig == SIGKILL)

		return 1;

	if (task_is_stopped_or_traced(p))

		return 0;

	return task_curr(p) || !signal_pending(p);

}



static void

__group_complete_signal(int sig, struct task_struct *p)

{

	struct signal_struct *signal = p->signal;

	struct task_struct *t;



	/*

	 * Now find a thread we can wake up to take the signal off the queue.

	 *

	 * If the main thread wants the signal, it gets first crack.

	 * Probably the least surprising to the average bear.

	 */

	if (wants_signal(sig, p))

		t = p;

	else if (thread_group_empty(p))

		/*

		 * There is just one thread and it does not need to be woken.

		 * It will dequeue unblocked signals before it runs again.

		 */

		return;

	else {

		/*

		 * Otherwise try to find a suitable thread.

		 */

		t = signal->curr_target;

		while (!wants_signal(sig, t)) {

			t = next_thread(t);

			if (t == signal->curr_target)

				/*

				 * No thread needs to be woken.

				 * Any eligible threads will see

				 * the signal in the queue soon.

				 */

				return;

		}

		signal->curr_target = t;

	}



	/*

	 * Found a killable thread.  If the signal will be fatal,

	 * then start taking the whole group down immediately.

	 */

	if (sig_fatal(p, sig) && !(signal->flags & SIGNAL_GROUP_EXIT) &&

	    !sigismember(&t->real_blocked, sig) &&

	    (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {

		/*

		 * This signal will be fatal to the whole group.

		 */

		if (!sig_kernel_coredump(sig)) {

			/*

			 * Start a group exit and wake everybody up.

			 * This way we don't have other threads

			 * running and doing things after a slower

			 * thread has the fatal signal pending.

			 */

			signal->flags = SIGNAL_GROUP_EXIT;

			signal->group_exit_code = sig;

			signal->group_stop_count = 0;

			t = p;

			do {

				sigaddset(&t->pending.signal, SIGKILL);

				signal_wake_up(t, 1);

			} while_each_thread(p, t);

			return;

		}

	}



	/*

	 * The signal is already in the shared-pending queue.

	 * Tell the chosen thread to wake up and dequeue it.

	 */

	signal_wake_up(t, sig == SIGKILL);

	return;

}



static inline int legacy_queue(struct sigpending *signals, int sig)

{

	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
@@ -817,102 +913,6 @@ force_sig_specific(int sig, struct task_struct *t) 
	force_sig_info(sig, SEND_SIG_FORCED, t);

}



/*

 * Test if P wants to take SIG.  After we've checked all threads with this,

 * it's equivalent to finding no threads not blocking SIG.  Any threads not

 * blocking SIG were ruled out because they are not running and already

 * have pending signals.  Such threads will dequeue from the shared queue

 * as soon as they're available, so putting the signal on the shared queue

 * will be equivalent to sending it to one such thread.

 */

static inline int wants_signal(int sig, struct task_struct *p)

{

	if (sigismember(&p->blocked, sig))

		return 0;

	if (p->flags & PF_EXITING)

		return 0;

	if (sig == SIGKILL)

		return 1;

	if (task_is_stopped_or_traced(p))

		return 0;

	return task_curr(p) || !signal_pending(p);

}



static void

__group_complete_signal(int sig, struct task_struct *p)

{

	struct signal_struct *signal = p->signal;

	struct task_struct *t;



	/*

	 * Now find a thread we can wake up to take the signal off the queue.

	 *

	 * If the main thread wants the signal, it gets first crack.

	 * Probably the least surprising to the average bear.

	 */

	if (wants_signal(sig, p))

		t = p;

	else if (thread_group_empty(p))

		/*

		 * There is just one thread and it does not need to be woken.

		 * It will dequeue unblocked signals before it runs again.

		 */

		return;

	else {

		/*

		 * Otherwise try to find a suitable thread.

		 */

		t = signal->curr_target;

		while (!wants_signal(sig, t)) {

			t = next_thread(t);

			if (t == signal->curr_target)

				/*

				 * No thread needs to be woken.

				 * Any eligible threads will see

				 * the signal in the queue soon.

				 */

				return;

		}

		signal->curr_target = t;

	}



	/*

	 * Found a killable thread.  If the signal will be fatal,

	 * then start taking the whole group down immediately.

	 */

	if (sig_fatal(p, sig) && !(signal->flags & SIGNAL_GROUP_EXIT) &&

	    !sigismember(&t->real_blocked, sig) &&

	    (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {

		/*

		 * This signal will be fatal to the whole group.

		 */

		if (!sig_kernel_coredump(sig)) {

			/*

			 * Start a group exit and wake everybody up.

			 * This way we don't have other threads

			 * running and doing things after a slower

			 * thread has the fatal signal pending.

			 */

			signal->flags = SIGNAL_GROUP_EXIT;

			signal->group_exit_code = sig;

			signal->group_stop_count = 0;

			t = p;

			do {

				sigaddset(&t->pending.signal, SIGKILL);

				signal_wake_up(t, 1);

			} while_each_thread(p, t);

			return;

		}

	}



	/*

	 * The signal is already in the shared-pending queue.

	 * Tell the chosen thread to wake up and dequeue it.

	 */

	signal_wake_up(t, sig == SIGKILL);

	return;

}



int

__group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)

{