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