xref: /openbmc/linux/kernel/signal.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *  linux/kernel/signal.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *
6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
7  *
8  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
9  *		Changes to use preallocated sigqueue structures
10  *		to allow signals to be sent reliably.
11  */
12 
13 #include <linux/config.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/smp_lock.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
19 #include <linux/fs.h>
20 #include <linux/tty.h>
21 #include <linux/binfmts.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/posix-timers.h>
26 #include <linux/signal.h>
27 #include <linux/audit.h>
28 #include <asm/param.h>
29 #include <asm/uaccess.h>
30 #include <asm/unistd.h>
31 #include <asm/siginfo.h>
32 
33 /*
34  * SLAB caches for signal bits.
35  */
36 
37 static kmem_cache_t *sigqueue_cachep;
38 
39 /*
40  * In POSIX a signal is sent either to a specific thread (Linux task)
41  * or to the process as a whole (Linux thread group).  How the signal
42  * is sent determines whether it's to one thread or the whole group,
43  * which determines which signal mask(s) are involved in blocking it
44  * from being delivered until later.  When the signal is delivered,
45  * either it's caught or ignored by a user handler or it has a default
46  * effect that applies to the whole thread group (POSIX process).
47  *
48  * The possible effects an unblocked signal set to SIG_DFL can have are:
49  *   ignore	- Nothing Happens
50  *   terminate	- kill the process, i.e. all threads in the group,
51  * 		  similar to exit_group.  The group leader (only) reports
52  *		  WIFSIGNALED status to its parent.
53  *   coredump	- write a core dump file describing all threads using
54  *		  the same mm and then kill all those threads
55  *   stop 	- stop all the threads in the group, i.e. TASK_STOPPED state
56  *
57  * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58  * Other signals when not blocked and set to SIG_DFL behaves as follows.
59  * The job control signals also have other special effects.
60  *
61  *	+--------------------+------------------+
62  *	|  POSIX signal      |  default action  |
63  *	+--------------------+------------------+
64  *	|  SIGHUP            |  terminate	|
65  *	|  SIGINT            |	terminate	|
66  *	|  SIGQUIT           |	coredump 	|
67  *	|  SIGILL            |	coredump 	|
68  *	|  SIGTRAP           |	coredump 	|
69  *	|  SIGABRT/SIGIOT    |	coredump 	|
70  *	|  SIGBUS            |	coredump 	|
71  *	|  SIGFPE            |	coredump 	|
72  *	|  SIGKILL           |	terminate(+)	|
73  *	|  SIGUSR1           |	terminate	|
74  *	|  SIGSEGV           |	coredump 	|
75  *	|  SIGUSR2           |	terminate	|
76  *	|  SIGPIPE           |	terminate	|
77  *	|  SIGALRM           |	terminate	|
78  *	|  SIGTERM           |	terminate	|
79  *	|  SIGCHLD           |	ignore   	|
80  *	|  SIGCONT           |	ignore(*)	|
81  *	|  SIGSTOP           |	stop(*)(+)  	|
82  *	|  SIGTSTP           |	stop(*)  	|
83  *	|  SIGTTIN           |	stop(*)  	|
84  *	|  SIGTTOU           |	stop(*)  	|
85  *	|  SIGURG            |	ignore   	|
86  *	|  SIGXCPU           |	coredump 	|
87  *	|  SIGXFSZ           |	coredump 	|
88  *	|  SIGVTALRM         |	terminate	|
89  *	|  SIGPROF           |	terminate	|
90  *	|  SIGPOLL/SIGIO     |	terminate	|
91  *	|  SIGSYS/SIGUNUSED  |	coredump 	|
92  *	|  SIGSTKFLT         |	terminate	|
93  *	|  SIGWINCH          |	ignore   	|
94  *	|  SIGPWR            |	terminate	|
95  *	|  SIGRTMIN-SIGRTMAX |	terminate       |
96  *	+--------------------+------------------+
97  *	|  non-POSIX signal  |  default action  |
98  *	+--------------------+------------------+
99  *	|  SIGEMT            |  coredump	|
100  *	+--------------------+------------------+
101  *
102  * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103  * (*) Special job control effects:
104  * When SIGCONT is sent, it resumes the process (all threads in the group)
105  * from TASK_STOPPED state and also clears any pending/queued stop signals
106  * (any of those marked with "stop(*)").  This happens regardless of blocking,
107  * catching, or ignoring SIGCONT.  When any stop signal is sent, it clears
108  * any pending/queued SIGCONT signals; this happens regardless of blocking,
109  * catching, or ignored the stop signal, though (except for SIGSTOP) the
110  * default action of stopping the process may happen later or never.
111  */
112 
113 #ifdef SIGEMT
114 #define M_SIGEMT	M(SIGEMT)
115 #else
116 #define M_SIGEMT	0
117 #endif
118 
119 #if SIGRTMIN > BITS_PER_LONG
120 #define M(sig) (1ULL << ((sig)-1))
121 #else
122 #define M(sig) (1UL << ((sig)-1))
123 #endif
124 #define T(sig, mask) (M(sig) & (mask))
125 
126 #define SIG_KERNEL_ONLY_MASK (\
127 	M(SIGKILL)   |  M(SIGSTOP)                                   )
128 
129 #define SIG_KERNEL_STOP_MASK (\
130 	M(SIGSTOP)   |  M(SIGTSTP)   |  M(SIGTTIN)   |  M(SIGTTOU)   )
131 
132 #define SIG_KERNEL_COREDUMP_MASK (\
133         M(SIGQUIT)   |  M(SIGILL)    |  M(SIGTRAP)   |  M(SIGABRT)   | \
134         M(SIGFPE)    |  M(SIGSEGV)   |  M(SIGBUS)    |  M(SIGSYS)    | \
135         M(SIGXCPU)   |  M(SIGXFSZ)   |  M_SIGEMT                     )
136 
137 #define SIG_KERNEL_IGNORE_MASK (\
138         M(SIGCONT)   |  M(SIGCHLD)   |  M(SIGWINCH)  |  M(SIGURG)    )
139 
140 #define sig_kernel_only(sig) \
141 		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_ONLY_MASK))
142 #define sig_kernel_coredump(sig) \
143 		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_COREDUMP_MASK))
144 #define sig_kernel_ignore(sig) \
145 		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_IGNORE_MASK))
146 #define sig_kernel_stop(sig) \
147 		(((sig) < SIGRTMIN)  && T(sig, SIG_KERNEL_STOP_MASK))
148 
149 #define sig_user_defined(t, signr) \
150 	(((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) &&	\
151 	 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
152 
153 #define sig_fatal(t, signr) \
154 	(!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
155 	 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
156 
157 static int sig_ignored(struct task_struct *t, int sig)
158 {
159 	void __user * handler;
160 
161 	/*
162 	 * Tracers always want to know about signals..
163 	 */
164 	if (t->ptrace & PT_PTRACED)
165 		return 0;
166 
167 	/*
168 	 * Blocked signals are never ignored, since the
169 	 * signal handler may change by the time it is
170 	 * unblocked.
171 	 */
172 	if (sigismember(&t->blocked, sig))
173 		return 0;
174 
175 	/* Is it explicitly or implicitly ignored? */
176 	handler = t->sighand->action[sig-1].sa.sa_handler;
177 	return   handler == SIG_IGN ||
178 		(handler == SIG_DFL && sig_kernel_ignore(sig));
179 }
180 
181 /*
182  * Re-calculate pending state from the set of locally pending
183  * signals, globally pending signals, and blocked signals.
184  */
185 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
186 {
187 	unsigned long ready;
188 	long i;
189 
190 	switch (_NSIG_WORDS) {
191 	default:
192 		for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
193 			ready |= signal->sig[i] &~ blocked->sig[i];
194 		break;
195 
196 	case 4: ready  = signal->sig[3] &~ blocked->sig[3];
197 		ready |= signal->sig[2] &~ blocked->sig[2];
198 		ready |= signal->sig[1] &~ blocked->sig[1];
199 		ready |= signal->sig[0] &~ blocked->sig[0];
200 		break;
201 
202 	case 2: ready  = signal->sig[1] &~ blocked->sig[1];
203 		ready |= signal->sig[0] &~ blocked->sig[0];
204 		break;
205 
206 	case 1: ready  = signal->sig[0] &~ blocked->sig[0];
207 	}
208 	return ready !=	0;
209 }
210 
211 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
212 
213 fastcall void recalc_sigpending_tsk(struct task_struct *t)
214 {
215 	if (t->signal->group_stop_count > 0 ||
216 	    (freezing(t)) ||
217 	    PENDING(&t->pending, &t->blocked) ||
218 	    PENDING(&t->signal->shared_pending, &t->blocked))
219 		set_tsk_thread_flag(t, TIF_SIGPENDING);
220 	else
221 		clear_tsk_thread_flag(t, TIF_SIGPENDING);
222 }
223 
224 void recalc_sigpending(void)
225 {
226 	recalc_sigpending_tsk(current);
227 }
228 
229 /* Given the mask, find the first available signal that should be serviced. */
230 
231 static int
232 next_signal(struct sigpending *pending, sigset_t *mask)
233 {
234 	unsigned long i, *s, *m, x;
235 	int sig = 0;
236 
237 	s = pending->signal.sig;
238 	m = mask->sig;
239 	switch (_NSIG_WORDS) {
240 	default:
241 		for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
242 			if ((x = *s &~ *m) != 0) {
243 				sig = ffz(~x) + i*_NSIG_BPW + 1;
244 				break;
245 			}
246 		break;
247 
248 	case 2: if ((x = s[0] &~ m[0]) != 0)
249 			sig = 1;
250 		else if ((x = s[1] &~ m[1]) != 0)
251 			sig = _NSIG_BPW + 1;
252 		else
253 			break;
254 		sig += ffz(~x);
255 		break;
256 
257 	case 1: if ((x = *s &~ *m) != 0)
258 			sig = ffz(~x) + 1;
259 		break;
260 	}
261 
262 	return sig;
263 }
264 
265 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
266 					 int override_rlimit)
267 {
268 	struct sigqueue *q = NULL;
269 
270 	atomic_inc(&t->user->sigpending);
271 	if (override_rlimit ||
272 	    atomic_read(&t->user->sigpending) <=
273 			t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
274 		q = kmem_cache_alloc(sigqueue_cachep, flags);
275 	if (unlikely(q == NULL)) {
276 		atomic_dec(&t->user->sigpending);
277 	} else {
278 		INIT_LIST_HEAD(&q->list);
279 		q->flags = 0;
280 		q->user = get_uid(t->user);
281 	}
282 	return(q);
283 }
284 
285 static inline void __sigqueue_free(struct sigqueue *q)
286 {
287 	if (q->flags & SIGQUEUE_PREALLOC)
288 		return;
289 	atomic_dec(&q->user->sigpending);
290 	free_uid(q->user);
291 	kmem_cache_free(sigqueue_cachep, q);
292 }
293 
294 static void flush_sigqueue(struct sigpending *queue)
295 {
296 	struct sigqueue *q;
297 
298 	sigemptyset(&queue->signal);
299 	while (!list_empty(&queue->list)) {
300 		q = list_entry(queue->list.next, struct sigqueue , list);
301 		list_del_init(&q->list);
302 		__sigqueue_free(q);
303 	}
304 }
305 
306 /*
307  * Flush all pending signals for a task.
308  */
309 
310 void
311 flush_signals(struct task_struct *t)
312 {
313 	unsigned long flags;
314 
315 	spin_lock_irqsave(&t->sighand->siglock, flags);
316 	clear_tsk_thread_flag(t,TIF_SIGPENDING);
317 	flush_sigqueue(&t->pending);
318 	flush_sigqueue(&t->signal->shared_pending);
319 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
320 }
321 
322 /*
323  * This function expects the tasklist_lock write-locked.
324  */
325 void __exit_sighand(struct task_struct *tsk)
326 {
327 	struct sighand_struct * sighand = tsk->sighand;
328 
329 	/* Ok, we're done with the signal handlers */
330 	tsk->sighand = NULL;
331 	if (atomic_dec_and_test(&sighand->count))
332 		kmem_cache_free(sighand_cachep, sighand);
333 }
334 
335 void exit_sighand(struct task_struct *tsk)
336 {
337 	write_lock_irq(&tasklist_lock);
338 	__exit_sighand(tsk);
339 	write_unlock_irq(&tasklist_lock);
340 }
341 
342 /*
343  * This function expects the tasklist_lock write-locked.
344  */
345 void __exit_signal(struct task_struct *tsk)
346 {
347 	struct signal_struct * sig = tsk->signal;
348 	struct sighand_struct * sighand = tsk->sighand;
349 
350 	if (!sig)
351 		BUG();
352 	if (!atomic_read(&sig->count))
353 		BUG();
354 	spin_lock(&sighand->siglock);
355 	posix_cpu_timers_exit(tsk);
356 	if (atomic_dec_and_test(&sig->count)) {
357 		posix_cpu_timers_exit_group(tsk);
358 		if (tsk == sig->curr_target)
359 			sig->curr_target = next_thread(tsk);
360 		tsk->signal = NULL;
361 		spin_unlock(&sighand->siglock);
362 		flush_sigqueue(&sig->shared_pending);
363 	} else {
364 		/*
365 		 * If there is any task waiting for the group exit
366 		 * then notify it:
367 		 */
368 		if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
369 			wake_up_process(sig->group_exit_task);
370 			sig->group_exit_task = NULL;
371 		}
372 		if (tsk == sig->curr_target)
373 			sig->curr_target = next_thread(tsk);
374 		tsk->signal = NULL;
375 		/*
376 		 * Accumulate here the counters for all threads but the
377 		 * group leader as they die, so they can be added into
378 		 * the process-wide totals when those are taken.
379 		 * The group leader stays around as a zombie as long
380 		 * as there are other threads.  When it gets reaped,
381 		 * the exit.c code will add its counts into these totals.
382 		 * We won't ever get here for the group leader, since it
383 		 * will have been the last reference on the signal_struct.
384 		 */
385 		sig->utime = cputime_add(sig->utime, tsk->utime);
386 		sig->stime = cputime_add(sig->stime, tsk->stime);
387 		sig->min_flt += tsk->min_flt;
388 		sig->maj_flt += tsk->maj_flt;
389 		sig->nvcsw += tsk->nvcsw;
390 		sig->nivcsw += tsk->nivcsw;
391 		sig->sched_time += tsk->sched_time;
392 		spin_unlock(&sighand->siglock);
393 		sig = NULL;	/* Marker for below.  */
394 	}
395 	clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
396 	flush_sigqueue(&tsk->pending);
397 	if (sig) {
398 		/*
399 		 * We are cleaning up the signal_struct here.
400 		 */
401 		exit_thread_group_keys(sig);
402 		kmem_cache_free(signal_cachep, sig);
403 	}
404 }
405 
406 void exit_signal(struct task_struct *tsk)
407 {
408 	atomic_dec(&tsk->signal->live);
409 
410 	write_lock_irq(&tasklist_lock);
411 	__exit_signal(tsk);
412 	write_unlock_irq(&tasklist_lock);
413 }
414 
415 /*
416  * Flush all handlers for a task.
417  */
418 
419 void
420 flush_signal_handlers(struct task_struct *t, int force_default)
421 {
422 	int i;
423 	struct k_sigaction *ka = &t->sighand->action[0];
424 	for (i = _NSIG ; i != 0 ; i--) {
425 		if (force_default || ka->sa.sa_handler != SIG_IGN)
426 			ka->sa.sa_handler = SIG_DFL;
427 		ka->sa.sa_flags = 0;
428 		sigemptyset(&ka->sa.sa_mask);
429 		ka++;
430 	}
431 }
432 
433 
434 /* Notify the system that a driver wants to block all signals for this
435  * process, and wants to be notified if any signals at all were to be
436  * sent/acted upon.  If the notifier routine returns non-zero, then the
437  * signal will be acted upon after all.  If the notifier routine returns 0,
438  * then then signal will be blocked.  Only one block per process is
439  * allowed.  priv is a pointer to private data that the notifier routine
440  * can use to determine if the signal should be blocked or not.  */
441 
442 void
443 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
444 {
445 	unsigned long flags;
446 
447 	spin_lock_irqsave(&current->sighand->siglock, flags);
448 	current->notifier_mask = mask;
449 	current->notifier_data = priv;
450 	current->notifier = notifier;
451 	spin_unlock_irqrestore(&current->sighand->siglock, flags);
452 }
453 
454 /* Notify the system that blocking has ended. */
455 
456 void
457 unblock_all_signals(void)
458 {
459 	unsigned long flags;
460 
461 	spin_lock_irqsave(&current->sighand->siglock, flags);
462 	current->notifier = NULL;
463 	current->notifier_data = NULL;
464 	recalc_sigpending();
465 	spin_unlock_irqrestore(&current->sighand->siglock, flags);
466 }
467 
468 static inline int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
469 {
470 	struct sigqueue *q, *first = NULL;
471 	int still_pending = 0;
472 
473 	if (unlikely(!sigismember(&list->signal, sig)))
474 		return 0;
475 
476 	/*
477 	 * Collect the siginfo appropriate to this signal.  Check if
478 	 * there is another siginfo for the same signal.
479 	*/
480 	list_for_each_entry(q, &list->list, list) {
481 		if (q->info.si_signo == sig) {
482 			if (first) {
483 				still_pending = 1;
484 				break;
485 			}
486 			first = q;
487 		}
488 	}
489 	if (first) {
490 		list_del_init(&first->list);
491 		copy_siginfo(info, &first->info);
492 		__sigqueue_free(first);
493 		if (!still_pending)
494 			sigdelset(&list->signal, sig);
495 	} else {
496 
497 		/* Ok, it wasn't in the queue.  This must be
498 		   a fast-pathed signal or we must have been
499 		   out of queue space.  So zero out the info.
500 		 */
501 		sigdelset(&list->signal, sig);
502 		info->si_signo = sig;
503 		info->si_errno = 0;
504 		info->si_code = 0;
505 		info->si_pid = 0;
506 		info->si_uid = 0;
507 	}
508 	return 1;
509 }
510 
511 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
512 			siginfo_t *info)
513 {
514 	int sig = 0;
515 
516 	/* SIGKILL must have priority, otherwise it is quite easy
517 	 * to create an unkillable process, sending sig < SIGKILL
518 	 * to self */
519 	if (unlikely(sigismember(&pending->signal, SIGKILL))) {
520 		if (!sigismember(mask, SIGKILL))
521 			sig = SIGKILL;
522 	}
523 
524 	if (likely(!sig))
525 		sig = next_signal(pending, mask);
526 	if (sig) {
527 		if (current->notifier) {
528 			if (sigismember(current->notifier_mask, sig)) {
529 				if (!(current->notifier)(current->notifier_data)) {
530 					clear_thread_flag(TIF_SIGPENDING);
531 					return 0;
532 				}
533 			}
534 		}
535 
536 		if (!collect_signal(sig, pending, info))
537 			sig = 0;
538 
539 	}
540 	recalc_sigpending();
541 
542 	return sig;
543 }
544 
545 /*
546  * Dequeue a signal and return the element to the caller, which is
547  * expected to free it.
548  *
549  * All callers have to hold the siglock.
550  */
551 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
552 {
553 	int signr = __dequeue_signal(&tsk->pending, mask, info);
554 	if (!signr)
555 		signr = __dequeue_signal(&tsk->signal->shared_pending,
556 					 mask, info);
557  	if (signr && unlikely(sig_kernel_stop(signr))) {
558  		/*
559  		 * Set a marker that we have dequeued a stop signal.  Our
560  		 * caller might release the siglock and then the pending
561  		 * stop signal it is about to process is no longer in the
562  		 * pending bitmasks, but must still be cleared by a SIGCONT
563  		 * (and overruled by a SIGKILL).  So those cases clear this
564  		 * shared flag after we've set it.  Note that this flag may
565  		 * remain set after the signal we return is ignored or
566  		 * handled.  That doesn't matter because its only purpose
567  		 * is to alert stop-signal processing code when another
568  		 * processor has come along and cleared the flag.
569  		 */
570  		if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
571  			tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
572  	}
573 	if ( signr &&
574 	     ((info->si_code & __SI_MASK) == __SI_TIMER) &&
575 	     info->si_sys_private){
576 		/*
577 		 * Release the siglock to ensure proper locking order
578 		 * of timer locks outside of siglocks.  Note, we leave
579 		 * irqs disabled here, since the posix-timers code is
580 		 * about to disable them again anyway.
581 		 */
582 		spin_unlock(&tsk->sighand->siglock);
583 		do_schedule_next_timer(info);
584 		spin_lock(&tsk->sighand->siglock);
585 	}
586 	return signr;
587 }
588 
589 /*
590  * Tell a process that it has a new active signal..
591  *
592  * NOTE! we rely on the previous spin_lock to
593  * lock interrupts for us! We can only be called with
594  * "siglock" held, and the local interrupt must
595  * have been disabled when that got acquired!
596  *
597  * No need to set need_resched since signal event passing
598  * goes through ->blocked
599  */
600 void signal_wake_up(struct task_struct *t, int resume)
601 {
602 	unsigned int mask;
603 
604 	set_tsk_thread_flag(t, TIF_SIGPENDING);
605 
606 	/*
607 	 * For SIGKILL, we want to wake it up in the stopped/traced case.
608 	 * We don't check t->state here because there is a race with it
609 	 * executing another processor and just now entering stopped state.
610 	 * By using wake_up_state, we ensure the process will wake up and
611 	 * handle its death signal.
612 	 */
613 	mask = TASK_INTERRUPTIBLE;
614 	if (resume)
615 		mask |= TASK_STOPPED | TASK_TRACED;
616 	if (!wake_up_state(t, mask))
617 		kick_process(t);
618 }
619 
620 /*
621  * Remove signals in mask from the pending set and queue.
622  * Returns 1 if any signals were found.
623  *
624  * All callers must be holding the siglock.
625  */
626 static int rm_from_queue(unsigned long mask, struct sigpending *s)
627 {
628 	struct sigqueue *q, *n;
629 
630 	if (!sigtestsetmask(&s->signal, mask))
631 		return 0;
632 
633 	sigdelsetmask(&s->signal, mask);
634 	list_for_each_entry_safe(q, n, &s->list, list) {
635 		if (q->info.si_signo < SIGRTMIN &&
636 		    (mask & sigmask(q->info.si_signo))) {
637 			list_del_init(&q->list);
638 			__sigqueue_free(q);
639 		}
640 	}
641 	return 1;
642 }
643 
644 /*
645  * Bad permissions for sending the signal
646  */
647 static int check_kill_permission(int sig, struct siginfo *info,
648 				 struct task_struct *t)
649 {
650 	int error = -EINVAL;
651 	if (!valid_signal(sig))
652 		return error;
653 	error = -EPERM;
654 	if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
655 	    && ((sig != SIGCONT) ||
656 		(current->signal->session != t->signal->session))
657 	    && (current->euid ^ t->suid) && (current->euid ^ t->uid)
658 	    && (current->uid ^ t->suid) && (current->uid ^ t->uid)
659 	    && !capable(CAP_KILL))
660 		return error;
661 
662 	error = security_task_kill(t, info, sig);
663 	if (!error)
664 		audit_signal_info(sig, t); /* Let audit system see the signal */
665 	return error;
666 }
667 
668 /* forward decl */
669 static void do_notify_parent_cldstop(struct task_struct *tsk,
670 				     int to_self,
671 				     int why);
672 
673 /*
674  * Handle magic process-wide effects of stop/continue signals.
675  * Unlike the signal actions, these happen immediately at signal-generation
676  * time regardless of blocking, ignoring, or handling.  This does the
677  * actual continuing for SIGCONT, but not the actual stopping for stop
678  * signals.  The process stop is done as a signal action for SIG_DFL.
679  */
680 static void handle_stop_signal(int sig, struct task_struct *p)
681 {
682 	struct task_struct *t;
683 
684 	if (p->signal->flags & SIGNAL_GROUP_EXIT)
685 		/*
686 		 * The process is in the middle of dying already.
687 		 */
688 		return;
689 
690 	if (sig_kernel_stop(sig)) {
691 		/*
692 		 * This is a stop signal.  Remove SIGCONT from all queues.
693 		 */
694 		rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
695 		t = p;
696 		do {
697 			rm_from_queue(sigmask(SIGCONT), &t->pending);
698 			t = next_thread(t);
699 		} while (t != p);
700 	} else if (sig == SIGCONT) {
701 		/*
702 		 * Remove all stop signals from all queues,
703 		 * and wake all threads.
704 		 */
705 		if (unlikely(p->signal->group_stop_count > 0)) {
706 			/*
707 			 * There was a group stop in progress.  We'll
708 			 * pretend it finished before we got here.  We are
709 			 * obliged to report it to the parent: if the
710 			 * SIGSTOP happened "after" this SIGCONT, then it
711 			 * would have cleared this pending SIGCONT.  If it
712 			 * happened "before" this SIGCONT, then the parent
713 			 * got the SIGCHLD about the stop finishing before
714 			 * the continue happened.  We do the notification
715 			 * now, and it's as if the stop had finished and
716 			 * the SIGCHLD was pending on entry to this kill.
717 			 */
718 			p->signal->group_stop_count = 0;
719 			p->signal->flags = SIGNAL_STOP_CONTINUED;
720 			spin_unlock(&p->sighand->siglock);
721 			do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_STOPPED);
722 			spin_lock(&p->sighand->siglock);
723 		}
724 		rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
725 		t = p;
726 		do {
727 			unsigned int state;
728 			rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
729 
730 			/*
731 			 * If there is a handler for SIGCONT, we must make
732 			 * sure that no thread returns to user mode before
733 			 * we post the signal, in case it was the only
734 			 * thread eligible to run the signal handler--then
735 			 * it must not do anything between resuming and
736 			 * running the handler.  With the TIF_SIGPENDING
737 			 * flag set, the thread will pause and acquire the
738 			 * siglock that we hold now and until we've queued
739 			 * the pending signal.
740 			 *
741 			 * Wake up the stopped thread _after_ setting
742 			 * TIF_SIGPENDING
743 			 */
744 			state = TASK_STOPPED;
745 			if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
746 				set_tsk_thread_flag(t, TIF_SIGPENDING);
747 				state |= TASK_INTERRUPTIBLE;
748 			}
749 			wake_up_state(t, state);
750 
751 			t = next_thread(t);
752 		} while (t != p);
753 
754 		if (p->signal->flags & SIGNAL_STOP_STOPPED) {
755 			/*
756 			 * We were in fact stopped, and are now continued.
757 			 * Notify the parent with CLD_CONTINUED.
758 			 */
759 			p->signal->flags = SIGNAL_STOP_CONTINUED;
760 			p->signal->group_exit_code = 0;
761 			spin_unlock(&p->sighand->siglock);
762 			do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_CONTINUED);
763 			spin_lock(&p->sighand->siglock);
764 		} else {
765 			/*
766 			 * We are not stopped, but there could be a stop
767 			 * signal in the middle of being processed after
768 			 * being removed from the queue.  Clear that too.
769 			 */
770 			p->signal->flags = 0;
771 		}
772 	} else if (sig == SIGKILL) {
773 		/*
774 		 * Make sure that any pending stop signal already dequeued
775 		 * is undone by the wakeup for SIGKILL.
776 		 */
777 		p->signal->flags = 0;
778 	}
779 }
780 
781 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
782 			struct sigpending *signals)
783 {
784 	struct sigqueue * q = NULL;
785 	int ret = 0;
786 
787 	/*
788 	 * fast-pathed signals for kernel-internal things like SIGSTOP
789 	 * or SIGKILL.
790 	 */
791 	if (info == SEND_SIG_FORCED)
792 		goto out_set;
793 
794 	/* Real-time signals must be queued if sent by sigqueue, or
795 	   some other real-time mechanism.  It is implementation
796 	   defined whether kill() does so.  We attempt to do so, on
797 	   the principle of least surprise, but since kill is not
798 	   allowed to fail with EAGAIN when low on memory we just
799 	   make sure at least one signal gets delivered and don't
800 	   pass on the info struct.  */
801 
802 	q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
803 					     (is_si_special(info) ||
804 					      info->si_code >= 0)));
805 	if (q) {
806 		list_add_tail(&q->list, &signals->list);
807 		switch ((unsigned long) info) {
808 		case (unsigned long) SEND_SIG_NOINFO:
809 			q->info.si_signo = sig;
810 			q->info.si_errno = 0;
811 			q->info.si_code = SI_USER;
812 			q->info.si_pid = current->pid;
813 			q->info.si_uid = current->uid;
814 			break;
815 		case (unsigned long) SEND_SIG_PRIV:
816 			q->info.si_signo = sig;
817 			q->info.si_errno = 0;
818 			q->info.si_code = SI_KERNEL;
819 			q->info.si_pid = 0;
820 			q->info.si_uid = 0;
821 			break;
822 		default:
823 			copy_siginfo(&q->info, info);
824 			break;
825 		}
826 	} else if (!is_si_special(info)) {
827 		if (sig >= SIGRTMIN && info->si_code != SI_USER)
828 		/*
829 		 * Queue overflow, abort.  We may abort if the signal was rt
830 		 * and sent by user using something other than kill().
831 		 */
832 			return -EAGAIN;
833 	}
834 
835 out_set:
836 	sigaddset(&signals->signal, sig);
837 	return ret;
838 }
839 
840 #define LEGACY_QUEUE(sigptr, sig) \
841 	(((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
842 
843 
844 static int
845 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
846 {
847 	int ret = 0;
848 
849 	if (!irqs_disabled())
850 		BUG();
851 	assert_spin_locked(&t->sighand->siglock);
852 
853 	/* Short-circuit ignored signals.  */
854 	if (sig_ignored(t, sig))
855 		goto out;
856 
857 	/* Support queueing exactly one non-rt signal, so that we
858 	   can get more detailed information about the cause of
859 	   the signal. */
860 	if (LEGACY_QUEUE(&t->pending, sig))
861 		goto out;
862 
863 	ret = send_signal(sig, info, t, &t->pending);
864 	if (!ret && !sigismember(&t->blocked, sig))
865 		signal_wake_up(t, sig == SIGKILL);
866 out:
867 	return ret;
868 }
869 
870 /*
871  * Force a signal that the process can't ignore: if necessary
872  * we unblock the signal and change any SIG_IGN to SIG_DFL.
873  */
874 
875 int
876 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
877 {
878 	unsigned long int flags;
879 	int ret;
880 
881 	spin_lock_irqsave(&t->sighand->siglock, flags);
882 	if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
883 		t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
884 	}
885 	if (sigismember(&t->blocked, sig)) {
886 		sigdelset(&t->blocked, sig);
887 	}
888 	recalc_sigpending_tsk(t);
889 	ret = specific_send_sig_info(sig, info, t);
890 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
891 
892 	return ret;
893 }
894 
895 void
896 force_sig_specific(int sig, struct task_struct *t)
897 {
898 	force_sig_info(sig, SEND_SIG_FORCED, t);
899 }
900 
901 /*
902  * Test if P wants to take SIG.  After we've checked all threads with this,
903  * it's equivalent to finding no threads not blocking SIG.  Any threads not
904  * blocking SIG were ruled out because they are not running and already
905  * have pending signals.  Such threads will dequeue from the shared queue
906  * as soon as they're available, so putting the signal on the shared queue
907  * will be equivalent to sending it to one such thread.
908  */
909 static inline int wants_signal(int sig, struct task_struct *p)
910 {
911 	if (sigismember(&p->blocked, sig))
912 		return 0;
913 	if (p->flags & PF_EXITING)
914 		return 0;
915 	if (sig == SIGKILL)
916 		return 1;
917 	if (p->state & (TASK_STOPPED | TASK_TRACED))
918 		return 0;
919 	return task_curr(p) || !signal_pending(p);
920 }
921 
922 static void
923 __group_complete_signal(int sig, struct task_struct *p)
924 {
925 	struct task_struct *t;
926 
927 	/*
928 	 * Now find a thread we can wake up to take the signal off the queue.
929 	 *
930 	 * If the main thread wants the signal, it gets first crack.
931 	 * Probably the least surprising to the average bear.
932 	 */
933 	if (wants_signal(sig, p))
934 		t = p;
935 	else if (thread_group_empty(p))
936 		/*
937 		 * There is just one thread and it does not need to be woken.
938 		 * It will dequeue unblocked signals before it runs again.
939 		 */
940 		return;
941 	else {
942 		/*
943 		 * Otherwise try to find a suitable thread.
944 		 */
945 		t = p->signal->curr_target;
946 		if (t == NULL)
947 			/* restart balancing at this thread */
948 			t = p->signal->curr_target = p;
949 		BUG_ON(t->tgid != p->tgid);
950 
951 		while (!wants_signal(sig, t)) {
952 			t = next_thread(t);
953 			if (t == p->signal->curr_target)
954 				/*
955 				 * No thread needs to be woken.
956 				 * Any eligible threads will see
957 				 * the signal in the queue soon.
958 				 */
959 				return;
960 		}
961 		p->signal->curr_target = t;
962 	}
963 
964 	/*
965 	 * Found a killable thread.  If the signal will be fatal,
966 	 * then start taking the whole group down immediately.
967 	 */
968 	if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
969 	    !sigismember(&t->real_blocked, sig) &&
970 	    (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
971 		/*
972 		 * This signal will be fatal to the whole group.
973 		 */
974 		if (!sig_kernel_coredump(sig)) {
975 			/*
976 			 * Start a group exit and wake everybody up.
977 			 * This way we don't have other threads
978 			 * running and doing things after a slower
979 			 * thread has the fatal signal pending.
980 			 */
981 			p->signal->flags = SIGNAL_GROUP_EXIT;
982 			p->signal->group_exit_code = sig;
983 			p->signal->group_stop_count = 0;
984 			t = p;
985 			do {
986 				sigaddset(&t->pending.signal, SIGKILL);
987 				signal_wake_up(t, 1);
988 				t = next_thread(t);
989 			} while (t != p);
990 			return;
991 		}
992 
993 		/*
994 		 * There will be a core dump.  We make all threads other
995 		 * than the chosen one go into a group stop so that nothing
996 		 * happens until it gets scheduled, takes the signal off
997 		 * the shared queue, and does the core dump.  This is a
998 		 * little more complicated than strictly necessary, but it
999 		 * keeps the signal state that winds up in the core dump
1000 		 * unchanged from the death state, e.g. which thread had
1001 		 * the core-dump signal unblocked.
1002 		 */
1003 		rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
1004 		rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
1005 		p->signal->group_stop_count = 0;
1006 		p->signal->group_exit_task = t;
1007 		t = p;
1008 		do {
1009 			p->signal->group_stop_count++;
1010 			signal_wake_up(t, 0);
1011 			t = next_thread(t);
1012 		} while (t != p);
1013 		wake_up_process(p->signal->group_exit_task);
1014 		return;
1015 	}
1016 
1017 	/*
1018 	 * The signal is already in the shared-pending queue.
1019 	 * Tell the chosen thread to wake up and dequeue it.
1020 	 */
1021 	signal_wake_up(t, sig == SIGKILL);
1022 	return;
1023 }
1024 
1025 int
1026 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1027 {
1028 	int ret = 0;
1029 
1030 	assert_spin_locked(&p->sighand->siglock);
1031 	handle_stop_signal(sig, p);
1032 
1033 	/* Short-circuit ignored signals.  */
1034 	if (sig_ignored(p, sig))
1035 		return ret;
1036 
1037 	if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1038 		/* This is a non-RT signal and we already have one queued.  */
1039 		return ret;
1040 
1041 	/*
1042 	 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1043 	 * We always use the shared queue for process-wide signals,
1044 	 * to avoid several races.
1045 	 */
1046 	ret = send_signal(sig, info, p, &p->signal->shared_pending);
1047 	if (unlikely(ret))
1048 		return ret;
1049 
1050 	__group_complete_signal(sig, p);
1051 	return 0;
1052 }
1053 
1054 /*
1055  * Nuke all other threads in the group.
1056  */
1057 void zap_other_threads(struct task_struct *p)
1058 {
1059 	struct task_struct *t;
1060 
1061 	p->signal->flags = SIGNAL_GROUP_EXIT;
1062 	p->signal->group_stop_count = 0;
1063 
1064 	if (thread_group_empty(p))
1065 		return;
1066 
1067 	for (t = next_thread(p); t != p; t = next_thread(t)) {
1068 		/*
1069 		 * Don't bother with already dead threads
1070 		 */
1071 		if (t->exit_state)
1072 			continue;
1073 
1074 		/*
1075 		 * We don't want to notify the parent, since we are
1076 		 * killed as part of a thread group due to another
1077 		 * thread doing an execve() or similar. So set the
1078 		 * exit signal to -1 to allow immediate reaping of
1079 		 * the process.  But don't detach the thread group
1080 		 * leader.
1081 		 */
1082 		if (t != p->group_leader)
1083 			t->exit_signal = -1;
1084 
1085 		/* SIGKILL will be handled before any pending SIGSTOP */
1086 		sigaddset(&t->pending.signal, SIGKILL);
1087 		signal_wake_up(t, 1);
1088 	}
1089 }
1090 
1091 /*
1092  * Must be called with the tasklist_lock held for reading!
1093  */
1094 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1095 {
1096 	unsigned long flags;
1097 	int ret;
1098 
1099 	ret = check_kill_permission(sig, info, p);
1100 	if (!ret && sig && p->sighand) {
1101 		spin_lock_irqsave(&p->sighand->siglock, flags);
1102 		ret = __group_send_sig_info(sig, info, p);
1103 		spin_unlock_irqrestore(&p->sighand->siglock, flags);
1104 	}
1105 
1106 	return ret;
1107 }
1108 
1109 /*
1110  * kill_pg_info() sends a signal to a process group: this is what the tty
1111  * control characters do (^C, ^Z etc)
1112  */
1113 
1114 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1115 {
1116 	struct task_struct *p = NULL;
1117 	int retval, success;
1118 
1119 	if (pgrp <= 0)
1120 		return -EINVAL;
1121 
1122 	success = 0;
1123 	retval = -ESRCH;
1124 	do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1125 		int err = group_send_sig_info(sig, info, p);
1126 		success |= !err;
1127 		retval = err;
1128 	} while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1129 	return success ? 0 : retval;
1130 }
1131 
1132 int
1133 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1134 {
1135 	int retval;
1136 
1137 	read_lock(&tasklist_lock);
1138 	retval = __kill_pg_info(sig, info, pgrp);
1139 	read_unlock(&tasklist_lock);
1140 
1141 	return retval;
1142 }
1143 
1144 int
1145 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1146 {
1147 	int error;
1148 	struct task_struct *p;
1149 
1150 	read_lock(&tasklist_lock);
1151 	p = find_task_by_pid(pid);
1152 	error = -ESRCH;
1153 	if (p)
1154 		error = group_send_sig_info(sig, info, p);
1155 	read_unlock(&tasklist_lock);
1156 	return error;
1157 }
1158 
1159 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1160 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1161 		      uid_t uid, uid_t euid)
1162 {
1163 	int ret = -EINVAL;
1164 	struct task_struct *p;
1165 
1166 	if (!valid_signal(sig))
1167 		return ret;
1168 
1169 	read_lock(&tasklist_lock);
1170 	p = find_task_by_pid(pid);
1171 	if (!p) {
1172 		ret = -ESRCH;
1173 		goto out_unlock;
1174 	}
1175 	if ((!info || ((unsigned long)info != 1 &&
1176 			(unsigned long)info != 2 && SI_FROMUSER(info)))
1177 	    && (euid != p->suid) && (euid != p->uid)
1178 	    && (uid != p->suid) && (uid != p->uid)) {
1179 		ret = -EPERM;
1180 		goto out_unlock;
1181 	}
1182 	if (sig && p->sighand) {
1183 		unsigned long flags;
1184 		spin_lock_irqsave(&p->sighand->siglock, flags);
1185 		ret = __group_send_sig_info(sig, info, p);
1186 		spin_unlock_irqrestore(&p->sighand->siglock, flags);
1187 	}
1188 out_unlock:
1189 	read_unlock(&tasklist_lock);
1190 	return ret;
1191 }
1192 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1193 
1194 /*
1195  * kill_something_info() interprets pid in interesting ways just like kill(2).
1196  *
1197  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1198  * is probably wrong.  Should make it like BSD or SYSV.
1199  */
1200 
1201 static int kill_something_info(int sig, struct siginfo *info, int pid)
1202 {
1203 	if (!pid) {
1204 		return kill_pg_info(sig, info, process_group(current));
1205 	} else if (pid == -1) {
1206 		int retval = 0, count = 0;
1207 		struct task_struct * p;
1208 
1209 		read_lock(&tasklist_lock);
1210 		for_each_process(p) {
1211 			if (p->pid > 1 && p->tgid != current->tgid) {
1212 				int err = group_send_sig_info(sig, info, p);
1213 				++count;
1214 				if (err != -EPERM)
1215 					retval = err;
1216 			}
1217 		}
1218 		read_unlock(&tasklist_lock);
1219 		return count ? retval : -ESRCH;
1220 	} else if (pid < 0) {
1221 		return kill_pg_info(sig, info, -pid);
1222 	} else {
1223 		return kill_proc_info(sig, info, pid);
1224 	}
1225 }
1226 
1227 /*
1228  * These are for backward compatibility with the rest of the kernel source.
1229  */
1230 
1231 /*
1232  * These two are the most common entry points.  They send a signal
1233  * just to the specific thread.
1234  */
1235 int
1236 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1237 {
1238 	int ret;
1239 	unsigned long flags;
1240 
1241 	/*
1242 	 * Make sure legacy kernel users don't send in bad values
1243 	 * (normal paths check this in check_kill_permission).
1244 	 */
1245 	if (!valid_signal(sig))
1246 		return -EINVAL;
1247 
1248 	/*
1249 	 * We need the tasklist lock even for the specific
1250 	 * thread case (when we don't need to follow the group
1251 	 * lists) in order to avoid races with "p->sighand"
1252 	 * going away or changing from under us.
1253 	 */
1254 	read_lock(&tasklist_lock);
1255 	spin_lock_irqsave(&p->sighand->siglock, flags);
1256 	ret = specific_send_sig_info(sig, info, p);
1257 	spin_unlock_irqrestore(&p->sighand->siglock, flags);
1258 	read_unlock(&tasklist_lock);
1259 	return ret;
1260 }
1261 
1262 #define __si_special(priv) \
1263 	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1264 
1265 int
1266 send_sig(int sig, struct task_struct *p, int priv)
1267 {
1268 	return send_sig_info(sig, __si_special(priv), p);
1269 }
1270 
1271 /*
1272  * This is the entry point for "process-wide" signals.
1273  * They will go to an appropriate thread in the thread group.
1274  */
1275 int
1276 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1277 {
1278 	int ret;
1279 	read_lock(&tasklist_lock);
1280 	ret = group_send_sig_info(sig, info, p);
1281 	read_unlock(&tasklist_lock);
1282 	return ret;
1283 }
1284 
1285 void
1286 force_sig(int sig, struct task_struct *p)
1287 {
1288 	force_sig_info(sig, SEND_SIG_PRIV, p);
1289 }
1290 
1291 /*
1292  * When things go south during signal handling, we
1293  * will force a SIGSEGV. And if the signal that caused
1294  * the problem was already a SIGSEGV, we'll want to
1295  * make sure we don't even try to deliver the signal..
1296  */
1297 int
1298 force_sigsegv(int sig, struct task_struct *p)
1299 {
1300 	if (sig == SIGSEGV) {
1301 		unsigned long flags;
1302 		spin_lock_irqsave(&p->sighand->siglock, flags);
1303 		p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1304 		spin_unlock_irqrestore(&p->sighand->siglock, flags);
1305 	}
1306 	force_sig(SIGSEGV, p);
1307 	return 0;
1308 }
1309 
1310 int
1311 kill_pg(pid_t pgrp, int sig, int priv)
1312 {
1313 	return kill_pg_info(sig, __si_special(priv), pgrp);
1314 }
1315 
1316 int
1317 kill_proc(pid_t pid, int sig, int priv)
1318 {
1319 	return kill_proc_info(sig, __si_special(priv), pid);
1320 }
1321 
1322 /*
1323  * These functions support sending signals using preallocated sigqueue
1324  * structures.  This is needed "because realtime applications cannot
1325  * afford to lose notifications of asynchronous events, like timer
1326  * expirations or I/O completions".  In the case of Posix Timers
1327  * we allocate the sigqueue structure from the timer_create.  If this
1328  * allocation fails we are able to report the failure to the application
1329  * with an EAGAIN error.
1330  */
1331 
1332 struct sigqueue *sigqueue_alloc(void)
1333 {
1334 	struct sigqueue *q;
1335 
1336 	if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1337 		q->flags |= SIGQUEUE_PREALLOC;
1338 	return(q);
1339 }
1340 
1341 void sigqueue_free(struct sigqueue *q)
1342 {
1343 	unsigned long flags;
1344 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1345 	/*
1346 	 * If the signal is still pending remove it from the
1347 	 * pending queue.
1348 	 */
1349 	if (unlikely(!list_empty(&q->list))) {
1350 		spinlock_t *lock = &current->sighand->siglock;
1351 		read_lock(&tasklist_lock);
1352 		spin_lock_irqsave(lock, flags);
1353 		if (!list_empty(&q->list))
1354 			list_del_init(&q->list);
1355 		spin_unlock_irqrestore(lock, flags);
1356 		read_unlock(&tasklist_lock);
1357 	}
1358 	q->flags &= ~SIGQUEUE_PREALLOC;
1359 	__sigqueue_free(q);
1360 }
1361 
1362 int
1363 send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1364 {
1365 	unsigned long flags;
1366 	int ret = 0;
1367 
1368 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1369 	read_lock(&tasklist_lock);
1370 
1371 	if (unlikely(p->flags & PF_EXITING)) {
1372 		ret = -1;
1373 		goto out_err;
1374 	}
1375 
1376 	spin_lock_irqsave(&p->sighand->siglock, flags);
1377 
1378 	if (unlikely(!list_empty(&q->list))) {
1379 		/*
1380 		 * If an SI_TIMER entry is already queue just increment
1381 		 * the overrun count.
1382 		 */
1383 		if (q->info.si_code != SI_TIMER)
1384 			BUG();
1385 		q->info.si_overrun++;
1386 		goto out;
1387 	}
1388 	/* Short-circuit ignored signals.  */
1389 	if (sig_ignored(p, sig)) {
1390 		ret = 1;
1391 		goto out;
1392 	}
1393 
1394 	list_add_tail(&q->list, &p->pending.list);
1395 	sigaddset(&p->pending.signal, sig);
1396 	if (!sigismember(&p->blocked, sig))
1397 		signal_wake_up(p, sig == SIGKILL);
1398 
1399 out:
1400 	spin_unlock_irqrestore(&p->sighand->siglock, flags);
1401 out_err:
1402 	read_unlock(&tasklist_lock);
1403 
1404 	return ret;
1405 }
1406 
1407 int
1408 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1409 {
1410 	unsigned long flags;
1411 	int ret = 0;
1412 
1413 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1414 	read_lock(&tasklist_lock);
1415 	spin_lock_irqsave(&p->sighand->siglock, flags);
1416 	handle_stop_signal(sig, p);
1417 
1418 	/* Short-circuit ignored signals.  */
1419 	if (sig_ignored(p, sig)) {
1420 		ret = 1;
1421 		goto out;
1422 	}
1423 
1424 	if (unlikely(!list_empty(&q->list))) {
1425 		/*
1426 		 * If an SI_TIMER entry is already queue just increment
1427 		 * the overrun count.  Other uses should not try to
1428 		 * send the signal multiple times.
1429 		 */
1430 		if (q->info.si_code != SI_TIMER)
1431 			BUG();
1432 		q->info.si_overrun++;
1433 		goto out;
1434 	}
1435 
1436 	/*
1437 	 * Put this signal on the shared-pending queue.
1438 	 * We always use the shared queue for process-wide signals,
1439 	 * to avoid several races.
1440 	 */
1441 	list_add_tail(&q->list, &p->signal->shared_pending.list);
1442 	sigaddset(&p->signal->shared_pending.signal, sig);
1443 
1444 	__group_complete_signal(sig, p);
1445 out:
1446 	spin_unlock_irqrestore(&p->sighand->siglock, flags);
1447 	read_unlock(&tasklist_lock);
1448 	return(ret);
1449 }
1450 
1451 /*
1452  * Wake up any threads in the parent blocked in wait* syscalls.
1453  */
1454 static inline void __wake_up_parent(struct task_struct *p,
1455 				    struct task_struct *parent)
1456 {
1457 	wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1458 }
1459 
1460 /*
1461  * Let a parent know about the death of a child.
1462  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1463  */
1464 
1465 void do_notify_parent(struct task_struct *tsk, int sig)
1466 {
1467 	struct siginfo info;
1468 	unsigned long flags;
1469 	struct sighand_struct *psig;
1470 
1471 	BUG_ON(sig == -1);
1472 
1473  	/* do_notify_parent_cldstop should have been called instead.  */
1474  	BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1475 
1476 	BUG_ON(!tsk->ptrace &&
1477 	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1478 
1479 	info.si_signo = sig;
1480 	info.si_errno = 0;
1481 	info.si_pid = tsk->pid;
1482 	info.si_uid = tsk->uid;
1483 
1484 	/* FIXME: find out whether or not this is supposed to be c*time. */
1485 	info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1486 						       tsk->signal->utime));
1487 	info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1488 						       tsk->signal->stime));
1489 
1490 	info.si_status = tsk->exit_code & 0x7f;
1491 	if (tsk->exit_code & 0x80)
1492 		info.si_code = CLD_DUMPED;
1493 	else if (tsk->exit_code & 0x7f)
1494 		info.si_code = CLD_KILLED;
1495 	else {
1496 		info.si_code = CLD_EXITED;
1497 		info.si_status = tsk->exit_code >> 8;
1498 	}
1499 
1500 	psig = tsk->parent->sighand;
1501 	spin_lock_irqsave(&psig->siglock, flags);
1502 	if (sig == SIGCHLD &&
1503 	    (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1504 	     (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1505 		/*
1506 		 * We are exiting and our parent doesn't care.  POSIX.1
1507 		 * defines special semantics for setting SIGCHLD to SIG_IGN
1508 		 * or setting the SA_NOCLDWAIT flag: we should be reaped
1509 		 * automatically and not left for our parent's wait4 call.
1510 		 * Rather than having the parent do it as a magic kind of
1511 		 * signal handler, we just set this to tell do_exit that we
1512 		 * can be cleaned up without becoming a zombie.  Note that
1513 		 * we still call __wake_up_parent in this case, because a
1514 		 * blocked sys_wait4 might now return -ECHILD.
1515 		 *
1516 		 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1517 		 * is implementation-defined: we do (if you don't want
1518 		 * it, just use SIG_IGN instead).
1519 		 */
1520 		tsk->exit_signal = -1;
1521 		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1522 			sig = 0;
1523 	}
1524 	if (valid_signal(sig) && sig > 0)
1525 		__group_send_sig_info(sig, &info, tsk->parent);
1526 	__wake_up_parent(tsk, tsk->parent);
1527 	spin_unlock_irqrestore(&psig->siglock, flags);
1528 }
1529 
1530 static void do_notify_parent_cldstop(struct task_struct *tsk, int to_self, int why)
1531 {
1532 	struct siginfo info;
1533 	unsigned long flags;
1534 	struct task_struct *parent;
1535 	struct sighand_struct *sighand;
1536 
1537 	if (to_self)
1538 		parent = tsk->parent;
1539 	else {
1540 		tsk = tsk->group_leader;
1541 		parent = tsk->real_parent;
1542 	}
1543 
1544 	info.si_signo = SIGCHLD;
1545 	info.si_errno = 0;
1546 	info.si_pid = tsk->pid;
1547 	info.si_uid = tsk->uid;
1548 
1549 	/* FIXME: find out whether or not this is supposed to be c*time. */
1550 	info.si_utime = cputime_to_jiffies(tsk->utime);
1551 	info.si_stime = cputime_to_jiffies(tsk->stime);
1552 
1553  	info.si_code = why;
1554  	switch (why) {
1555  	case CLD_CONTINUED:
1556  		info.si_status = SIGCONT;
1557  		break;
1558  	case CLD_STOPPED:
1559  		info.si_status = tsk->signal->group_exit_code & 0x7f;
1560  		break;
1561  	case CLD_TRAPPED:
1562  		info.si_status = tsk->exit_code & 0x7f;
1563  		break;
1564  	default:
1565  		BUG();
1566  	}
1567 
1568 	sighand = parent->sighand;
1569 	spin_lock_irqsave(&sighand->siglock, flags);
1570 	if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1571 	    !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1572 		__group_send_sig_info(SIGCHLD, &info, parent);
1573 	/*
1574 	 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1575 	 */
1576 	__wake_up_parent(tsk, parent);
1577 	spin_unlock_irqrestore(&sighand->siglock, flags);
1578 }
1579 
1580 /*
1581  * This must be called with current->sighand->siglock held.
1582  *
1583  * This should be the path for all ptrace stops.
1584  * We always set current->last_siginfo while stopped here.
1585  * That makes it a way to test a stopped process for
1586  * being ptrace-stopped vs being job-control-stopped.
1587  *
1588  * If we actually decide not to stop at all because the tracer is gone,
1589  * we leave nostop_code in current->exit_code.
1590  */
1591 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1592 {
1593 	/*
1594 	 * If there is a group stop in progress,
1595 	 * we must participate in the bookkeeping.
1596 	 */
1597 	if (current->signal->group_stop_count > 0)
1598 		--current->signal->group_stop_count;
1599 
1600 	current->last_siginfo = info;
1601 	current->exit_code = exit_code;
1602 
1603 	/* Let the debugger run.  */
1604 	set_current_state(TASK_TRACED);
1605 	spin_unlock_irq(&current->sighand->siglock);
1606 	read_lock(&tasklist_lock);
1607 	if (likely(current->ptrace & PT_PTRACED) &&
1608 	    likely(current->parent != current->real_parent ||
1609 		   !(current->ptrace & PT_ATTACHED)) &&
1610 	    (likely(current->parent->signal != current->signal) ||
1611 	     !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1612 		do_notify_parent_cldstop(current, 1, CLD_TRAPPED);
1613 		read_unlock(&tasklist_lock);
1614 		schedule();
1615 	} else {
1616 		/*
1617 		 * By the time we got the lock, our tracer went away.
1618 		 * Don't stop here.
1619 		 */
1620 		read_unlock(&tasklist_lock);
1621 		set_current_state(TASK_RUNNING);
1622 		current->exit_code = nostop_code;
1623 	}
1624 
1625 	/*
1626 	 * We are back.  Now reacquire the siglock before touching
1627 	 * last_siginfo, so that we are sure to have synchronized with
1628 	 * any signal-sending on another CPU that wants to examine it.
1629 	 */
1630 	spin_lock_irq(&current->sighand->siglock);
1631 	current->last_siginfo = NULL;
1632 
1633 	/*
1634 	 * Queued signals ignored us while we were stopped for tracing.
1635 	 * So check for any that we should take before resuming user mode.
1636 	 */
1637 	recalc_sigpending();
1638 }
1639 
1640 void ptrace_notify(int exit_code)
1641 {
1642 	siginfo_t info;
1643 
1644 	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1645 
1646 	memset(&info, 0, sizeof info);
1647 	info.si_signo = SIGTRAP;
1648 	info.si_code = exit_code;
1649 	info.si_pid = current->pid;
1650 	info.si_uid = current->uid;
1651 
1652 	/* Let the debugger run.  */
1653 	spin_lock_irq(&current->sighand->siglock);
1654 	ptrace_stop(exit_code, 0, &info);
1655 	spin_unlock_irq(&current->sighand->siglock);
1656 }
1657 
1658 static void
1659 finish_stop(int stop_count)
1660 {
1661 	int to_self;
1662 
1663 	/*
1664 	 * If there are no other threads in the group, or if there is
1665 	 * a group stop in progress and we are the last to stop,
1666 	 * report to the parent.  When ptraced, every thread reports itself.
1667 	 */
1668 	if (stop_count < 0 || (current->ptrace & PT_PTRACED))
1669 		to_self = 1;
1670 	else if (stop_count == 0)
1671 		to_self = 0;
1672 	else
1673 		goto out;
1674 
1675 	read_lock(&tasklist_lock);
1676 	do_notify_parent_cldstop(current, to_self, CLD_STOPPED);
1677 	read_unlock(&tasklist_lock);
1678 
1679 out:
1680 	schedule();
1681 	/*
1682 	 * Now we don't run again until continued.
1683 	 */
1684 	current->exit_code = 0;
1685 }
1686 
1687 /*
1688  * This performs the stopping for SIGSTOP and other stop signals.
1689  * We have to stop all threads in the thread group.
1690  * Returns nonzero if we've actually stopped and released the siglock.
1691  * Returns zero if we didn't stop and still hold the siglock.
1692  */
1693 static int
1694 do_signal_stop(int signr)
1695 {
1696 	struct signal_struct *sig = current->signal;
1697 	struct sighand_struct *sighand = current->sighand;
1698 	int stop_count = -1;
1699 
1700 	if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1701 		return 0;
1702 
1703 	if (sig->group_stop_count > 0) {
1704 		/*
1705 		 * There is a group stop in progress.  We don't need to
1706 		 * start another one.
1707 		 */
1708 		signr = sig->group_exit_code;
1709 		stop_count = --sig->group_stop_count;
1710 		current->exit_code = signr;
1711 		set_current_state(TASK_STOPPED);
1712 		if (stop_count == 0)
1713 			sig->flags = SIGNAL_STOP_STOPPED;
1714 		spin_unlock_irq(&sighand->siglock);
1715 	}
1716 	else if (thread_group_empty(current)) {
1717 		/*
1718 		 * Lock must be held through transition to stopped state.
1719 		 */
1720 		current->exit_code = current->signal->group_exit_code = signr;
1721 		set_current_state(TASK_STOPPED);
1722 		sig->flags = SIGNAL_STOP_STOPPED;
1723 		spin_unlock_irq(&sighand->siglock);
1724 	}
1725 	else {
1726 		/*
1727 		 * There is no group stop already in progress.
1728 		 * We must initiate one now, but that requires
1729 		 * dropping siglock to get both the tasklist lock
1730 		 * and siglock again in the proper order.  Note that
1731 		 * this allows an intervening SIGCONT to be posted.
1732 		 * We need to check for that and bail out if necessary.
1733 		 */
1734 		struct task_struct *t;
1735 
1736 		spin_unlock_irq(&sighand->siglock);
1737 
1738 		/* signals can be posted during this window */
1739 
1740 		read_lock(&tasklist_lock);
1741 		spin_lock_irq(&sighand->siglock);
1742 
1743 		if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED)) {
1744 			/*
1745 			 * Another stop or continue happened while we
1746 			 * didn't have the lock.  We can just swallow this
1747 			 * signal now.  If we raced with a SIGCONT, that
1748 			 * should have just cleared it now.  If we raced
1749 			 * with another processor delivering a stop signal,
1750 			 * then the SIGCONT that wakes us up should clear it.
1751 			 */
1752 			read_unlock(&tasklist_lock);
1753 			return 0;
1754 		}
1755 
1756 		if (sig->group_stop_count == 0) {
1757 			sig->group_exit_code = signr;
1758 			stop_count = 0;
1759 			for (t = next_thread(current); t != current;
1760 			     t = next_thread(t))
1761 				/*
1762 				 * Setting state to TASK_STOPPED for a group
1763 				 * stop is always done with the siglock held,
1764 				 * so this check has no races.
1765 				 */
1766 				if (!t->exit_state &&
1767 				    !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1768 					stop_count++;
1769 					signal_wake_up(t, 0);
1770 				}
1771 			sig->group_stop_count = stop_count;
1772 		}
1773 		else {
1774 			/* A race with another thread while unlocked.  */
1775 			signr = sig->group_exit_code;
1776 			stop_count = --sig->group_stop_count;
1777 		}
1778 
1779 		current->exit_code = signr;
1780 		set_current_state(TASK_STOPPED);
1781 		if (stop_count == 0)
1782 			sig->flags = SIGNAL_STOP_STOPPED;
1783 
1784 		spin_unlock_irq(&sighand->siglock);
1785 		read_unlock(&tasklist_lock);
1786 	}
1787 
1788 	finish_stop(stop_count);
1789 	return 1;
1790 }
1791 
1792 /*
1793  * Do appropriate magic when group_stop_count > 0.
1794  * We return nonzero if we stopped, after releasing the siglock.
1795  * We return zero if we still hold the siglock and should look
1796  * for another signal without checking group_stop_count again.
1797  */
1798 static inline int handle_group_stop(void)
1799 {
1800 	int stop_count;
1801 
1802 	if (current->signal->group_exit_task == current) {
1803 		/*
1804 		 * Group stop is so we can do a core dump,
1805 		 * We are the initiating thread, so get on with it.
1806 		 */
1807 		current->signal->group_exit_task = NULL;
1808 		return 0;
1809 	}
1810 
1811 	if (current->signal->flags & SIGNAL_GROUP_EXIT)
1812 		/*
1813 		 * Group stop is so another thread can do a core dump,
1814 		 * or else we are racing against a death signal.
1815 		 * Just punt the stop so we can get the next signal.
1816 		 */
1817 		return 0;
1818 
1819 	/*
1820 	 * There is a group stop in progress.  We stop
1821 	 * without any associated signal being in our queue.
1822 	 */
1823 	stop_count = --current->signal->group_stop_count;
1824 	if (stop_count == 0)
1825 		current->signal->flags = SIGNAL_STOP_STOPPED;
1826 	current->exit_code = current->signal->group_exit_code;
1827 	set_current_state(TASK_STOPPED);
1828 	spin_unlock_irq(&current->sighand->siglock);
1829 	finish_stop(stop_count);
1830 	return 1;
1831 }
1832 
1833 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1834 			  struct pt_regs *regs, void *cookie)
1835 {
1836 	sigset_t *mask = &current->blocked;
1837 	int signr = 0;
1838 
1839 relock:
1840 	spin_lock_irq(&current->sighand->siglock);
1841 	for (;;) {
1842 		struct k_sigaction *ka;
1843 
1844 		if (unlikely(current->signal->group_stop_count > 0) &&
1845 		    handle_group_stop())
1846 			goto relock;
1847 
1848 		signr = dequeue_signal(current, mask, info);
1849 
1850 		if (!signr)
1851 			break; /* will return 0 */
1852 
1853 		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1854 			ptrace_signal_deliver(regs, cookie);
1855 
1856 			/* Let the debugger run.  */
1857 			ptrace_stop(signr, signr, info);
1858 
1859 			/* We're back.  Did the debugger cancel the sig or group_exit? */
1860 			signr = current->exit_code;
1861 			if (signr == 0 || current->signal->flags & SIGNAL_GROUP_EXIT)
1862 				continue;
1863 
1864 			current->exit_code = 0;
1865 
1866 			/* Update the siginfo structure if the signal has
1867 			   changed.  If the debugger wanted something
1868 			   specific in the siginfo structure then it should
1869 			   have updated *info via PTRACE_SETSIGINFO.  */
1870 			if (signr != info->si_signo) {
1871 				info->si_signo = signr;
1872 				info->si_errno = 0;
1873 				info->si_code = SI_USER;
1874 				info->si_pid = current->parent->pid;
1875 				info->si_uid = current->parent->uid;
1876 			}
1877 
1878 			/* If the (new) signal is now blocked, requeue it.  */
1879 			if (sigismember(&current->blocked, signr)) {
1880 				specific_send_sig_info(signr, info, current);
1881 				continue;
1882 			}
1883 		}
1884 
1885 		ka = &current->sighand->action[signr-1];
1886 		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1887 			continue;
1888 		if (ka->sa.sa_handler != SIG_DFL) {
1889 			/* Run the handler.  */
1890 			*return_ka = *ka;
1891 
1892 			if (ka->sa.sa_flags & SA_ONESHOT)
1893 				ka->sa.sa_handler = SIG_DFL;
1894 
1895 			break; /* will return non-zero "signr" value */
1896 		}
1897 
1898 		/*
1899 		 * Now we are doing the default action for this signal.
1900 		 */
1901 		if (sig_kernel_ignore(signr)) /* Default is nothing. */
1902 			continue;
1903 
1904 		/* Init gets no signals it doesn't want.  */
1905 		if (current->pid == 1)
1906 			continue;
1907 
1908 		if (sig_kernel_stop(signr)) {
1909 			/*
1910 			 * The default action is to stop all threads in
1911 			 * the thread group.  The job control signals
1912 			 * do nothing in an orphaned pgrp, but SIGSTOP
1913 			 * always works.  Note that siglock needs to be
1914 			 * dropped during the call to is_orphaned_pgrp()
1915 			 * because of lock ordering with tasklist_lock.
1916 			 * This allows an intervening SIGCONT to be posted.
1917 			 * We need to check for that and bail out if necessary.
1918 			 */
1919 			if (signr != SIGSTOP) {
1920 				spin_unlock_irq(&current->sighand->siglock);
1921 
1922 				/* signals can be posted during this window */
1923 
1924 				if (is_orphaned_pgrp(process_group(current)))
1925 					goto relock;
1926 
1927 				spin_lock_irq(&current->sighand->siglock);
1928 			}
1929 
1930 			if (likely(do_signal_stop(signr))) {
1931 				/* It released the siglock.  */
1932 				goto relock;
1933 			}
1934 
1935 			/*
1936 			 * We didn't actually stop, due to a race
1937 			 * with SIGCONT or something like that.
1938 			 */
1939 			continue;
1940 		}
1941 
1942 		spin_unlock_irq(&current->sighand->siglock);
1943 
1944 		/*
1945 		 * Anything else is fatal, maybe with a core dump.
1946 		 */
1947 		current->flags |= PF_SIGNALED;
1948 		if (sig_kernel_coredump(signr)) {
1949 			/*
1950 			 * If it was able to dump core, this kills all
1951 			 * other threads in the group and synchronizes with
1952 			 * their demise.  If we lost the race with another
1953 			 * thread getting here, it set group_exit_code
1954 			 * first and our do_group_exit call below will use
1955 			 * that value and ignore the one we pass it.
1956 			 */
1957 			do_coredump((long)signr, signr, regs);
1958 		}
1959 
1960 		/*
1961 		 * Death signals, no core dump.
1962 		 */
1963 		do_group_exit(signr);
1964 		/* NOTREACHED */
1965 	}
1966 	spin_unlock_irq(&current->sighand->siglock);
1967 	return signr;
1968 }
1969 
1970 EXPORT_SYMBOL(recalc_sigpending);
1971 EXPORT_SYMBOL_GPL(dequeue_signal);
1972 EXPORT_SYMBOL(flush_signals);
1973 EXPORT_SYMBOL(force_sig);
1974 EXPORT_SYMBOL(kill_pg);
1975 EXPORT_SYMBOL(kill_proc);
1976 EXPORT_SYMBOL(ptrace_notify);
1977 EXPORT_SYMBOL(send_sig);
1978 EXPORT_SYMBOL(send_sig_info);
1979 EXPORT_SYMBOL(sigprocmask);
1980 EXPORT_SYMBOL(block_all_signals);
1981 EXPORT_SYMBOL(unblock_all_signals);
1982 
1983 
1984 /*
1985  * System call entry points.
1986  */
1987 
1988 asmlinkage long sys_restart_syscall(void)
1989 {
1990 	struct restart_block *restart = &current_thread_info()->restart_block;
1991 	return restart->fn(restart);
1992 }
1993 
1994 long do_no_restart_syscall(struct restart_block *param)
1995 {
1996 	return -EINTR;
1997 }
1998 
1999 /*
2000  * We don't need to get the kernel lock - this is all local to this
2001  * particular thread.. (and that's good, because this is _heavily_
2002  * used by various programs)
2003  */
2004 
2005 /*
2006  * This is also useful for kernel threads that want to temporarily
2007  * (or permanently) block certain signals.
2008  *
2009  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2010  * interface happily blocks "unblockable" signals like SIGKILL
2011  * and friends.
2012  */
2013 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2014 {
2015 	int error;
2016 	sigset_t old_block;
2017 
2018 	spin_lock_irq(&current->sighand->siglock);
2019 	old_block = current->blocked;
2020 	error = 0;
2021 	switch (how) {
2022 	case SIG_BLOCK:
2023 		sigorsets(&current->blocked, &current->blocked, set);
2024 		break;
2025 	case SIG_UNBLOCK:
2026 		signandsets(&current->blocked, &current->blocked, set);
2027 		break;
2028 	case SIG_SETMASK:
2029 		current->blocked = *set;
2030 		break;
2031 	default:
2032 		error = -EINVAL;
2033 	}
2034 	recalc_sigpending();
2035 	spin_unlock_irq(&current->sighand->siglock);
2036 	if (oldset)
2037 		*oldset = old_block;
2038 	return error;
2039 }
2040 
2041 asmlinkage long
2042 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2043 {
2044 	int error = -EINVAL;
2045 	sigset_t old_set, new_set;
2046 
2047 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2048 	if (sigsetsize != sizeof(sigset_t))
2049 		goto out;
2050 
2051 	if (set) {
2052 		error = -EFAULT;
2053 		if (copy_from_user(&new_set, set, sizeof(*set)))
2054 			goto out;
2055 		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2056 
2057 		error = sigprocmask(how, &new_set, &old_set);
2058 		if (error)
2059 			goto out;
2060 		if (oset)
2061 			goto set_old;
2062 	} else if (oset) {
2063 		spin_lock_irq(&current->sighand->siglock);
2064 		old_set = current->blocked;
2065 		spin_unlock_irq(&current->sighand->siglock);
2066 
2067 	set_old:
2068 		error = -EFAULT;
2069 		if (copy_to_user(oset, &old_set, sizeof(*oset)))
2070 			goto out;
2071 	}
2072 	error = 0;
2073 out:
2074 	return error;
2075 }
2076 
2077 long do_sigpending(void __user *set, unsigned long sigsetsize)
2078 {
2079 	long error = -EINVAL;
2080 	sigset_t pending;
2081 
2082 	if (sigsetsize > sizeof(sigset_t))
2083 		goto out;
2084 
2085 	spin_lock_irq(&current->sighand->siglock);
2086 	sigorsets(&pending, &current->pending.signal,
2087 		  &current->signal->shared_pending.signal);
2088 	spin_unlock_irq(&current->sighand->siglock);
2089 
2090 	/* Outside the lock because only this thread touches it.  */
2091 	sigandsets(&pending, &current->blocked, &pending);
2092 
2093 	error = -EFAULT;
2094 	if (!copy_to_user(set, &pending, sigsetsize))
2095 		error = 0;
2096 
2097 out:
2098 	return error;
2099 }
2100 
2101 asmlinkage long
2102 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2103 {
2104 	return do_sigpending(set, sigsetsize);
2105 }
2106 
2107 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2108 
2109 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2110 {
2111 	int err;
2112 
2113 	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2114 		return -EFAULT;
2115 	if (from->si_code < 0)
2116 		return __copy_to_user(to, from, sizeof(siginfo_t))
2117 			? -EFAULT : 0;
2118 	/*
2119 	 * If you change siginfo_t structure, please be sure
2120 	 * this code is fixed accordingly.
2121 	 * It should never copy any pad contained in the structure
2122 	 * to avoid security leaks, but must copy the generic
2123 	 * 3 ints plus the relevant union member.
2124 	 */
2125 	err = __put_user(from->si_signo, &to->si_signo);
2126 	err |= __put_user(from->si_errno, &to->si_errno);
2127 	err |= __put_user((short)from->si_code, &to->si_code);
2128 	switch (from->si_code & __SI_MASK) {
2129 	case __SI_KILL:
2130 		err |= __put_user(from->si_pid, &to->si_pid);
2131 		err |= __put_user(from->si_uid, &to->si_uid);
2132 		break;
2133 	case __SI_TIMER:
2134 		 err |= __put_user(from->si_tid, &to->si_tid);
2135 		 err |= __put_user(from->si_overrun, &to->si_overrun);
2136 		 err |= __put_user(from->si_ptr, &to->si_ptr);
2137 		break;
2138 	case __SI_POLL:
2139 		err |= __put_user(from->si_band, &to->si_band);
2140 		err |= __put_user(from->si_fd, &to->si_fd);
2141 		break;
2142 	case __SI_FAULT:
2143 		err |= __put_user(from->si_addr, &to->si_addr);
2144 #ifdef __ARCH_SI_TRAPNO
2145 		err |= __put_user(from->si_trapno, &to->si_trapno);
2146 #endif
2147 		break;
2148 	case __SI_CHLD:
2149 		err |= __put_user(from->si_pid, &to->si_pid);
2150 		err |= __put_user(from->si_uid, &to->si_uid);
2151 		err |= __put_user(from->si_status, &to->si_status);
2152 		err |= __put_user(from->si_utime, &to->si_utime);
2153 		err |= __put_user(from->si_stime, &to->si_stime);
2154 		break;
2155 	case __SI_RT: /* This is not generated by the kernel as of now. */
2156 	case __SI_MESGQ: /* But this is */
2157 		err |= __put_user(from->si_pid, &to->si_pid);
2158 		err |= __put_user(from->si_uid, &to->si_uid);
2159 		err |= __put_user(from->si_ptr, &to->si_ptr);
2160 		break;
2161 	default: /* this is just in case for now ... */
2162 		err |= __put_user(from->si_pid, &to->si_pid);
2163 		err |= __put_user(from->si_uid, &to->si_uid);
2164 		break;
2165 	}
2166 	return err;
2167 }
2168 
2169 #endif
2170 
2171 asmlinkage long
2172 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2173 		    siginfo_t __user *uinfo,
2174 		    const struct timespec __user *uts,
2175 		    size_t sigsetsize)
2176 {
2177 	int ret, sig;
2178 	sigset_t these;
2179 	struct timespec ts;
2180 	siginfo_t info;
2181 	long timeout = 0;
2182 
2183 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2184 	if (sigsetsize != sizeof(sigset_t))
2185 		return -EINVAL;
2186 
2187 	if (copy_from_user(&these, uthese, sizeof(these)))
2188 		return -EFAULT;
2189 
2190 	/*
2191 	 * Invert the set of allowed signals to get those we
2192 	 * want to block.
2193 	 */
2194 	sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2195 	signotset(&these);
2196 
2197 	if (uts) {
2198 		if (copy_from_user(&ts, uts, sizeof(ts)))
2199 			return -EFAULT;
2200 		if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2201 		    || ts.tv_sec < 0)
2202 			return -EINVAL;
2203 	}
2204 
2205 	spin_lock_irq(&current->sighand->siglock);
2206 	sig = dequeue_signal(current, &these, &info);
2207 	if (!sig) {
2208 		timeout = MAX_SCHEDULE_TIMEOUT;
2209 		if (uts)
2210 			timeout = (timespec_to_jiffies(&ts)
2211 				   + (ts.tv_sec || ts.tv_nsec));
2212 
2213 		if (timeout) {
2214 			/* None ready -- temporarily unblock those we're
2215 			 * interested while we are sleeping in so that we'll
2216 			 * be awakened when they arrive.  */
2217 			current->real_blocked = current->blocked;
2218 			sigandsets(&current->blocked, &current->blocked, &these);
2219 			recalc_sigpending();
2220 			spin_unlock_irq(&current->sighand->siglock);
2221 
2222 			timeout = schedule_timeout_interruptible(timeout);
2223 
2224 			try_to_freeze();
2225 			spin_lock_irq(&current->sighand->siglock);
2226 			sig = dequeue_signal(current, &these, &info);
2227 			current->blocked = current->real_blocked;
2228 			siginitset(&current->real_blocked, 0);
2229 			recalc_sigpending();
2230 		}
2231 	}
2232 	spin_unlock_irq(&current->sighand->siglock);
2233 
2234 	if (sig) {
2235 		ret = sig;
2236 		if (uinfo) {
2237 			if (copy_siginfo_to_user(uinfo, &info))
2238 				ret = -EFAULT;
2239 		}
2240 	} else {
2241 		ret = -EAGAIN;
2242 		if (timeout)
2243 			ret = -EINTR;
2244 	}
2245 
2246 	return ret;
2247 }
2248 
2249 asmlinkage long
2250 sys_kill(int pid, int sig)
2251 {
2252 	struct siginfo info;
2253 
2254 	info.si_signo = sig;
2255 	info.si_errno = 0;
2256 	info.si_code = SI_USER;
2257 	info.si_pid = current->tgid;
2258 	info.si_uid = current->uid;
2259 
2260 	return kill_something_info(sig, &info, pid);
2261 }
2262 
2263 static int do_tkill(int tgid, int pid, int sig)
2264 {
2265 	int error;
2266 	struct siginfo info;
2267 	struct task_struct *p;
2268 
2269 	error = -ESRCH;
2270 	info.si_signo = sig;
2271 	info.si_errno = 0;
2272 	info.si_code = SI_TKILL;
2273 	info.si_pid = current->tgid;
2274 	info.si_uid = current->uid;
2275 
2276 	read_lock(&tasklist_lock);
2277 	p = find_task_by_pid(pid);
2278 	if (p && (tgid <= 0 || p->tgid == tgid)) {
2279 		error = check_kill_permission(sig, &info, p);
2280 		/*
2281 		 * The null signal is a permissions and process existence
2282 		 * probe.  No signal is actually delivered.
2283 		 */
2284 		if (!error && sig && p->sighand) {
2285 			spin_lock_irq(&p->sighand->siglock);
2286 			handle_stop_signal(sig, p);
2287 			error = specific_send_sig_info(sig, &info, p);
2288 			spin_unlock_irq(&p->sighand->siglock);
2289 		}
2290 	}
2291 	read_unlock(&tasklist_lock);
2292 
2293 	return error;
2294 }
2295 
2296 /**
2297  *  sys_tgkill - send signal to one specific thread
2298  *  @tgid: the thread group ID of the thread
2299  *  @pid: the PID of the thread
2300  *  @sig: signal to be sent
2301  *
2302  *  This syscall also checks the tgid and returns -ESRCH even if the PID
2303  *  exists but it's not belonging to the target process anymore. This
2304  *  method solves the problem of threads exiting and PIDs getting reused.
2305  */
2306 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2307 {
2308 	/* This is only valid for single tasks */
2309 	if (pid <= 0 || tgid <= 0)
2310 		return -EINVAL;
2311 
2312 	return do_tkill(tgid, pid, sig);
2313 }
2314 
2315 /*
2316  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2317  */
2318 asmlinkage long
2319 sys_tkill(int pid, int sig)
2320 {
2321 	/* This is only valid for single tasks */
2322 	if (pid <= 0)
2323 		return -EINVAL;
2324 
2325 	return do_tkill(0, pid, sig);
2326 }
2327 
2328 asmlinkage long
2329 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2330 {
2331 	siginfo_t info;
2332 
2333 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2334 		return -EFAULT;
2335 
2336 	/* Not even root can pretend to send signals from the kernel.
2337 	   Nor can they impersonate a kill(), which adds source info.  */
2338 	if (info.si_code >= 0)
2339 		return -EPERM;
2340 	info.si_signo = sig;
2341 
2342 	/* POSIX.1b doesn't mention process groups.  */
2343 	return kill_proc_info(sig, &info, pid);
2344 }
2345 
2346 int
2347 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
2348 {
2349 	struct k_sigaction *k;
2350 
2351 	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2352 		return -EINVAL;
2353 
2354 	k = &current->sighand->action[sig-1];
2355 
2356 	spin_lock_irq(&current->sighand->siglock);
2357 	if (signal_pending(current)) {
2358 		/*
2359 		 * If there might be a fatal signal pending on multiple
2360 		 * threads, make sure we take it before changing the action.
2361 		 */
2362 		spin_unlock_irq(&current->sighand->siglock);
2363 		return -ERESTARTNOINTR;
2364 	}
2365 
2366 	if (oact)
2367 		*oact = *k;
2368 
2369 	if (act) {
2370 		/*
2371 		 * POSIX 3.3.1.3:
2372 		 *  "Setting a signal action to SIG_IGN for a signal that is
2373 		 *   pending shall cause the pending signal to be discarded,
2374 		 *   whether or not it is blocked."
2375 		 *
2376 		 *  "Setting a signal action to SIG_DFL for a signal that is
2377 		 *   pending and whose default action is to ignore the signal
2378 		 *   (for example, SIGCHLD), shall cause the pending signal to
2379 		 *   be discarded, whether or not it is blocked"
2380 		 */
2381 		if (act->sa.sa_handler == SIG_IGN ||
2382 		    (act->sa.sa_handler == SIG_DFL &&
2383 		     sig_kernel_ignore(sig))) {
2384 			/*
2385 			 * This is a fairly rare case, so we only take the
2386 			 * tasklist_lock once we're sure we'll need it.
2387 			 * Now we must do this little unlock and relock
2388 			 * dance to maintain the lock hierarchy.
2389 			 */
2390 			struct task_struct *t = current;
2391 			spin_unlock_irq(&t->sighand->siglock);
2392 			read_lock(&tasklist_lock);
2393 			spin_lock_irq(&t->sighand->siglock);
2394 			*k = *act;
2395 			sigdelsetmask(&k->sa.sa_mask,
2396 				      sigmask(SIGKILL) | sigmask(SIGSTOP));
2397 			rm_from_queue(sigmask(sig), &t->signal->shared_pending);
2398 			do {
2399 				rm_from_queue(sigmask(sig), &t->pending);
2400 				recalc_sigpending_tsk(t);
2401 				t = next_thread(t);
2402 			} while (t != current);
2403 			spin_unlock_irq(&current->sighand->siglock);
2404 			read_unlock(&tasklist_lock);
2405 			return 0;
2406 		}
2407 
2408 		*k = *act;
2409 		sigdelsetmask(&k->sa.sa_mask,
2410 			      sigmask(SIGKILL) | sigmask(SIGSTOP));
2411 	}
2412 
2413 	spin_unlock_irq(&current->sighand->siglock);
2414 	return 0;
2415 }
2416 
2417 int
2418 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2419 {
2420 	stack_t oss;
2421 	int error;
2422 
2423 	if (uoss) {
2424 		oss.ss_sp = (void __user *) current->sas_ss_sp;
2425 		oss.ss_size = current->sas_ss_size;
2426 		oss.ss_flags = sas_ss_flags(sp);
2427 	}
2428 
2429 	if (uss) {
2430 		void __user *ss_sp;
2431 		size_t ss_size;
2432 		int ss_flags;
2433 
2434 		error = -EFAULT;
2435 		if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2436 		    || __get_user(ss_sp, &uss->ss_sp)
2437 		    || __get_user(ss_flags, &uss->ss_flags)
2438 		    || __get_user(ss_size, &uss->ss_size))
2439 			goto out;
2440 
2441 		error = -EPERM;
2442 		if (on_sig_stack(sp))
2443 			goto out;
2444 
2445 		error = -EINVAL;
2446 		/*
2447 		 *
2448 		 * Note - this code used to test ss_flags incorrectly
2449 		 *  	  old code may have been written using ss_flags==0
2450 		 *	  to mean ss_flags==SS_ONSTACK (as this was the only
2451 		 *	  way that worked) - this fix preserves that older
2452 		 *	  mechanism
2453 		 */
2454 		if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2455 			goto out;
2456 
2457 		if (ss_flags == SS_DISABLE) {
2458 			ss_size = 0;
2459 			ss_sp = NULL;
2460 		} else {
2461 			error = -ENOMEM;
2462 			if (ss_size < MINSIGSTKSZ)
2463 				goto out;
2464 		}
2465 
2466 		current->sas_ss_sp = (unsigned long) ss_sp;
2467 		current->sas_ss_size = ss_size;
2468 	}
2469 
2470 	if (uoss) {
2471 		error = -EFAULT;
2472 		if (copy_to_user(uoss, &oss, sizeof(oss)))
2473 			goto out;
2474 	}
2475 
2476 	error = 0;
2477 out:
2478 	return error;
2479 }
2480 
2481 #ifdef __ARCH_WANT_SYS_SIGPENDING
2482 
2483 asmlinkage long
2484 sys_sigpending(old_sigset_t __user *set)
2485 {
2486 	return do_sigpending(set, sizeof(*set));
2487 }
2488 
2489 #endif
2490 
2491 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2492 /* Some platforms have their own version with special arguments others
2493    support only sys_rt_sigprocmask.  */
2494 
2495 asmlinkage long
2496 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2497 {
2498 	int error;
2499 	old_sigset_t old_set, new_set;
2500 
2501 	if (set) {
2502 		error = -EFAULT;
2503 		if (copy_from_user(&new_set, set, sizeof(*set)))
2504 			goto out;
2505 		new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2506 
2507 		spin_lock_irq(&current->sighand->siglock);
2508 		old_set = current->blocked.sig[0];
2509 
2510 		error = 0;
2511 		switch (how) {
2512 		default:
2513 			error = -EINVAL;
2514 			break;
2515 		case SIG_BLOCK:
2516 			sigaddsetmask(&current->blocked, new_set);
2517 			break;
2518 		case SIG_UNBLOCK:
2519 			sigdelsetmask(&current->blocked, new_set);
2520 			break;
2521 		case SIG_SETMASK:
2522 			current->blocked.sig[0] = new_set;
2523 			break;
2524 		}
2525 
2526 		recalc_sigpending();
2527 		spin_unlock_irq(&current->sighand->siglock);
2528 		if (error)
2529 			goto out;
2530 		if (oset)
2531 			goto set_old;
2532 	} else if (oset) {
2533 		old_set = current->blocked.sig[0];
2534 	set_old:
2535 		error = -EFAULT;
2536 		if (copy_to_user(oset, &old_set, sizeof(*oset)))
2537 			goto out;
2538 	}
2539 	error = 0;
2540 out:
2541 	return error;
2542 }
2543 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2544 
2545 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2546 asmlinkage long
2547 sys_rt_sigaction(int sig,
2548 		 const struct sigaction __user *act,
2549 		 struct sigaction __user *oact,
2550 		 size_t sigsetsize)
2551 {
2552 	struct k_sigaction new_sa, old_sa;
2553 	int ret = -EINVAL;
2554 
2555 	/* XXX: Don't preclude handling different sized sigset_t's.  */
2556 	if (sigsetsize != sizeof(sigset_t))
2557 		goto out;
2558 
2559 	if (act) {
2560 		if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2561 			return -EFAULT;
2562 	}
2563 
2564 	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2565 
2566 	if (!ret && oact) {
2567 		if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2568 			return -EFAULT;
2569 	}
2570 out:
2571 	return ret;
2572 }
2573 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2574 
2575 #ifdef __ARCH_WANT_SYS_SGETMASK
2576 
2577 /*
2578  * For backwards compatibility.  Functionality superseded by sigprocmask.
2579  */
2580 asmlinkage long
2581 sys_sgetmask(void)
2582 {
2583 	/* SMP safe */
2584 	return current->blocked.sig[0];
2585 }
2586 
2587 asmlinkage long
2588 sys_ssetmask(int newmask)
2589 {
2590 	int old;
2591 
2592 	spin_lock_irq(&current->sighand->siglock);
2593 	old = current->blocked.sig[0];
2594 
2595 	siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2596 						  sigmask(SIGSTOP)));
2597 	recalc_sigpending();
2598 	spin_unlock_irq(&current->sighand->siglock);
2599 
2600 	return old;
2601 }
2602 #endif /* __ARCH_WANT_SGETMASK */
2603 
2604 #ifdef __ARCH_WANT_SYS_SIGNAL
2605 /*
2606  * For backwards compatibility.  Functionality superseded by sigaction.
2607  */
2608 asmlinkage unsigned long
2609 sys_signal(int sig, __sighandler_t handler)
2610 {
2611 	struct k_sigaction new_sa, old_sa;
2612 	int ret;
2613 
2614 	new_sa.sa.sa_handler = handler;
2615 	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2616 
2617 	ret = do_sigaction(sig, &new_sa, &old_sa);
2618 
2619 	return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2620 }
2621 #endif /* __ARCH_WANT_SYS_SIGNAL */
2622 
2623 #ifdef __ARCH_WANT_SYS_PAUSE
2624 
2625 asmlinkage long
2626 sys_pause(void)
2627 {
2628 	current->state = TASK_INTERRUPTIBLE;
2629 	schedule();
2630 	return -ERESTARTNOHAND;
2631 }
2632 
2633 #endif
2634 
2635 void __init signals_init(void)
2636 {
2637 	sigqueue_cachep =
2638 		kmem_cache_create("sigqueue",
2639 				  sizeof(struct sigqueue),
2640 				  __alignof__(struct sigqueue),
2641 				  SLAB_PANIC, NULL, NULL);
2642 }
2643