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