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