~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* linux/kernel/signal.c
3	4	*
..	..	@@ -19,8 +20,8 @@
19	20	#include <linux/sched/task.h>
20	21	#include <linux/sched/task_stack.h>
21	22	#include <linux/sched/cputime.h>
22		-#include <linux/file.h>
23	23	#include <linux/sched/rt.h>
	24	+#include <linux/file.h>
24	25	#include <linux/fs.h>
25	26	#include <linux/proc_fs.h>
26	27	#include <linux/tty.h>
..	..	@@ -45,6 +46,8 @@
45	46	#include <linux/posix-timers.h>
46	47	#include <linux/livepatch.h>
47	48	#include <linux/cgroup.h>
	49	+#include <linux/audit.h>
	50	+#include <linux/oom.h>
48	51
49	52	#define CREATE_TRACE_POINTS
50	53	#include <trace/events/signal.h>
..	..	@@ -54,8 +57,9 @@
54	57	#include <asm/unistd.h>
55	58	#include <asm/siginfo.h>
56	59	#include <asm/cacheflush.h>
57		-#include "audit.h" /* audit_signal_info() */
58	60
	61	+#undef CREATE_TRACE_POINTS
	62	+#include <trace/hooks/signal.h>
59	63	/*
60	64	* SLAB caches for signal bits.
61	65	*/
..	..	@@ -186,6 +190,7 @@
186	190	clear_thread_flag(TIF_SIGPENDING);
187	191
188	192	}
	193	+EXPORT_SYMBOL(recalc_sigpending);
189	194
190	195	void calculate_sigpending(void)
191	196	{
..	..	@@ -353,7 +358,7 @@
353	358	* @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
354	359	* Group stop states are cleared and the group stop count is consumed if
355	360	* %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
356		- * stop, the appropriate %SIGNAL_* flags are set.
	361	+ * stop, the appropriate `SIGNAL_*` flags are set.
357	362	*
358	363	* CONTEXT:
359	364	* Must be called with @task->sighand->siglock held.
..	..	@@ -539,6 +544,7 @@
539	544	flush_sigqueue(&t->signal->shared_pending);
540	545	spin_unlock_irqrestore(&t->sighand->siglock, flags);
541	546	}
	547	+EXPORT_SYMBOL(flush_signals);
542	548
543	549	#ifdef CONFIG_POSIX_TIMERS
544	550	static void __flush_itimer_signals(struct sigpending *pending)
..	..	@@ -620,7 +626,7 @@
620	626	return !tsk->ptrace;
621	627	}
622	628
623		-static void collect_signal(int sig, struct sigpending list, siginfo_t info,
	629	+static void collect_signal(int sig, struct sigpending list, kernel_siginfo_t info,
624	630	bool *resched_timer)
625	631	{
626	632	struct sigqueue q, first = NULL;
..	..	@@ -666,7 +672,7 @@
666	672	}
667	673
668	674	static int __dequeue_signal(struct sigpending pending, sigset_t mask,
669		- siginfo_t info, bool resched_timer)
	675	+ kernel_siginfo_t info, bool resched_timer)
670	676	{
671	677	int sig = next_signal(pending, mask);
672	678
..	..	@@ -681,7 +687,7 @@
681	687	*
682	688	* All callers have to hold the siglock.
683	689	*/
684		-int dequeue_signal(struct task_struct tsk, sigset_t mask, siginfo_t *info)
	690	+int dequeue_signal(struct task_struct tsk, sigset_t mask, kernel_siginfo_t *info)
685	691	{
686	692	bool resched_timer = false;
687	693	int signr;
..	..	@@ -759,8 +765,9 @@
759	765	#endif
760	766	return signr;
761	767	}
	768	+EXPORT_SYMBOL_GPL(dequeue_signal);
762	769
763		-static int dequeue_synchronous_signal(siginfo_t *info)
	770	+static int dequeue_synchronous_signal(kernel_siginfo_t *info)
764	771	{
765	772	struct task_struct *tsk = current;
766	773	struct sigpending *pending = &tsk->pending;
..	..	@@ -776,7 +783,7 @@
776	783	* Return the first synchronous signal in the queue.
777	784	*/
778	785	list_for_each_entry(q, &pending->list, list) {
779		- /* Synchronous signals have a postive si_code */
	786	+ /* Synchronous signals have a positive si_code */
780	787	if ((q->info.si_code > SI_USER) &&
781	788	(sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
782	789	sync = q;
..	..	@@ -851,12 +858,12 @@
851	858	}
852	859	}
853	860
854		-static inline int is_si_special(const struct siginfo *info)
	861	+static inline int is_si_special(const struct kernel_siginfo *info)
855	862	{
856		- return info <= SEND_SIG_FORCED;
	863	+ return info <= SEND_SIG_PRIV;
857	864	}
858	865
859		-static inline bool si_fromuser(const struct siginfo *info)
	866	+static inline bool si_fromuser(const struct kernel_siginfo *info)
860	867	{
861	868	return info == SEND_SIG_NOINFO \|\|
862	869	(!is_si_special(info) && SI_FROMUSER(info));
..	..	@@ -881,7 +888,7 @@
881	888	* Bad permissions for sending the signal
882	889	* - the caller must hold the RCU read lock
883	890	*/
884		-static int check_kill_permission(int sig, struct siginfo *info,
	891	+static int check_kill_permission(int sig, struct kernel_siginfo *info,
885	892	struct task_struct *t)
886	893	{
887	894	struct pid *sid;
..	..	@@ -908,6 +915,7 @@
908	915	*/
909	916	if (!sid \|\| sid == task_session(current))
910	917	break;
	918	+ fallthrough;
911	919	default:
912	920	return -EPERM;
913	921	}
..	..	@@ -1006,7 +1014,7 @@
1006	1014	/*
1007	1015	* The first thread which returns from do_signal_stop()
1008	1016	* will take ->siglock, notice SIGNAL_CLD_MASK, and
1009		- * notify its parent. See get_signal_to_deliver().
	1017	+ * notify its parent. See get_signal().
1010	1018	*/
1011	1019	signal_set_stop_flags(signal, why \| SIGNAL_STOP_CONTINUED);
1012	1020	signal->group_stop_count = 0;
..	..	@@ -1039,7 +1047,7 @@
1039	1047	if (task_is_stopped_or_traced(p))
1040	1048	return false;
1041	1049
1042		- return task_curr(p) \|\| !signal_pending(p);
	1050	+ return task_curr(p) \|\| !task_sigpending(p);
1043	1051	}
1044	1052
1045	1053	static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
..	..	@@ -1123,29 +1131,8 @@
1123	1131	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1124	1132	}
1125	1133
1126		-#ifdef CONFIG_USER_NS
1127		-static inline void userns_fixup_signal_uid(struct siginfo info, struct task_struct t)
1128		-{
1129		- if (current_user_ns() == task_cred_xxx(t, user_ns))
1130		- return;
1131		-
1132		- if (SI_FROMKERNEL(info))
1133		- return;
1134		-
1135		- rcu_read_lock();
1136		- info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
1137		- make_kuid(current_user_ns(), info->si_uid));
1138		- rcu_read_unlock();
1139		-}
1140		-#else
1141		-static inline void userns_fixup_signal_uid(struct siginfo info, struct task_struct t)
1142		-{
1143		- return;
1144		-}
1145		-#endif
1146		-
1147		-static int __send_signal(int sig, struct siginfo info, struct task_struct t,
1148		- enum pid_type type, int from_ancestor_ns)
	1134	+static int __send_signal(int sig, struct kernel_siginfo info, struct task_struct t,
	1135	+ enum pid_type type, bool force)
1149	1136	{
1150	1137	struct sigpending *pending;
1151	1138	struct sigqueue *q;
..	..	@@ -1155,8 +1142,7 @@
1155	1142	assert_spin_locked(&t->sighand->siglock);
1156	1143
1157	1144	result = TRACE_SIGNAL_IGNORED;
1158		- if (!prepare_signal(sig, t,
1159		- from_ancestor_ns \|\| (info == SEND_SIG_PRIV) \|\| (info == SEND_SIG_FORCED)))
	1145	+ if (!prepare_signal(sig, t, force))
1160	1146	goto ret;
1161	1147
1162	1148	pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
..	..	@@ -1171,10 +1157,9 @@
1171	1157
1172	1158	result = TRACE_SIGNAL_DELIVERED;
1173	1159	/*
1174		- * fast-pathed signals for kernel-internal things like SIGSTOP
1175		- * or SIGKILL.
	1160	+ * Skip useless siginfo allocation for SIGKILL and kernel threads.
1176	1161	*/
1177		- if (info == SEND_SIG_FORCED)
	1162	+ if ((sig == SIGKILL) \|\| (t->flags & PF_KTHREAD))
1178	1163	goto out_set;
1179	1164
1180	1165	/*
..	..	@@ -1202,7 +1187,11 @@
1202	1187	q->info.si_code = SI_USER;
1203	1188	q->info.si_pid = task_tgid_nr_ns(current,
1204	1189	task_active_pid_ns(t));
1205		- q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
	1190	+ rcu_read_lock();
	1191	+ q->info.si_uid =
	1192	+ from_kuid_munged(task_cred_xxx(t, user_ns),
	1193	+ current_uid());
	1194	+ rcu_read_unlock();
1206	1195	break;
1207	1196	case (unsigned long) SEND_SIG_PRIV:
1208	1197	clear_siginfo(&q->info);
..	..	@@ -1214,30 +1203,24 @@
1214	1203	break;
1215	1204	default:
1216	1205	copy_siginfo(&q->info, info);
1217		- if (from_ancestor_ns)
1218		- q->info.si_pid = 0;
1219	1206	break;
1220	1207	}
1221		-
1222		- userns_fixup_signal_uid(&q->info, t);
1223		-
1224		- } else if (!is_si_special(info)) {
1225		- if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1226		- /*
1227		- * Queue overflow, abort. We may abort if the
1228		- * signal was rt and sent by user using something
1229		- * other than kill().
1230		- */
1231		- result = TRACE_SIGNAL_OVERFLOW_FAIL;
1232		- ret = -EAGAIN;
1233		- goto ret;
1234		- } else {
1235		- /*
1236		- * This is a silent loss of information. We still
1237		- * send the signal, but the *info bits are lost.
1238		- */
1239		- result = TRACE_SIGNAL_LOSE_INFO;
1240		- }
	1208	+ } else if (!is_si_special(info) &&
	1209	+ sig >= SIGRTMIN && info->si_code != SI_USER) {
	1210	+ /*
	1211	+ * Queue overflow, abort. We may abort if the
	1212	+ * signal was rt and sent by user using something
	1213	+ * other than kill().
	1214	+ */
	1215	+ result = TRACE_SIGNAL_OVERFLOW_FAIL;
	1216	+ ret = -EAGAIN;
	1217	+ goto ret;
	1218	+ } else {
	1219	+ /*
	1220	+ * This is a silent loss of information. We still
	1221	+ * send the signal, but the *info bits are lost.
	1222	+ */
	1223	+ result = TRACE_SIGNAL_LOSE_INFO;
1241	1224	}
1242	1225
1243	1226	out_set:
..	..	@@ -1264,17 +1247,62 @@
1264	1247	return ret;
1265	1248	}
1266	1249
1267		-static int send_signal(int sig, struct siginfo info, struct task_struct t,
	1250	+static inline bool has_si_pid_and_uid(struct kernel_siginfo *info)
	1251	+{
	1252	+ bool ret = false;
	1253	+ switch (siginfo_layout(info->si_signo, info->si_code)) {
	1254	+ case SIL_KILL:
	1255	+ case SIL_CHLD:
	1256	+ case SIL_RT:
	1257	+ ret = true;
	1258	+ break;
	1259	+ case SIL_TIMER:
	1260	+ case SIL_POLL:
	1261	+ case SIL_FAULT:
	1262	+ case SIL_FAULT_MCEERR:
	1263	+ case SIL_FAULT_BNDERR:
	1264	+ case SIL_FAULT_PKUERR:
	1265	+ case SIL_SYS:
	1266	+ ret = false;
	1267	+ break;
	1268	+ }
	1269	+ return ret;
	1270	+}
	1271	+
	1272	+static int send_signal(int sig, struct kernel_siginfo info, struct task_struct t,
1268	1273	enum pid_type type)
1269	1274	{
1270		- int from_ancestor_ns = 0;
	1275	+ /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */
	1276	+ bool force = false;
1271	1277
1272		-#ifdef CONFIG_PID_NS
1273		- from_ancestor_ns = si_fromuser(info) &&
1274		- !task_pid_nr_ns(current, task_active_pid_ns(t));
1275		-#endif
	1278	+ if (info == SEND_SIG_NOINFO) {
	1279	+ /* Force if sent from an ancestor pid namespace */
	1280	+ force = !task_pid_nr_ns(current, task_active_pid_ns(t));
	1281	+ } else if (info == SEND_SIG_PRIV) {
	1282	+ /* Don't ignore kernel generated signals */
	1283	+ force = true;
	1284	+ } else if (has_si_pid_and_uid(info)) {
	1285	+ /* SIGKILL and SIGSTOP is special or has ids */
	1286	+ struct user_namespace *t_user_ns;
1276	1287
1277		- return __send_signal(sig, info, t, type, from_ancestor_ns);
	1288	+ rcu_read_lock();
	1289	+ t_user_ns = task_cred_xxx(t, user_ns);
	1290	+ if (current_user_ns() != t_user_ns) {
	1291	+ kuid_t uid = make_kuid(current_user_ns(), info->si_uid);
	1292	+ info->si_uid = from_kuid_munged(t_user_ns, uid);
	1293	+ }
	1294	+ rcu_read_unlock();
	1295	+
	1296	+ /* A kernel generated signal? */
	1297	+ force = (info->si_code == SI_KERNEL);
	1298	+
	1299	+ /* From an ancestor pid namespace? */
	1300	+ if (!task_pid_nr_ns(current, task_active_pid_ns(t))) {
	1301	+ info->si_pid = 0;
	1302	+ force = true;
	1303	+ }
	1304	+ }
	1305	+ return __send_signal(sig, info, t, type, force);
1278	1306	}
1279	1307
1280	1308	static void print_fatal_signal(int signr)
..	..	@@ -1311,23 +1339,17 @@
1311	1339	__setup("print-fatal-signals=", setup_print_fatal_signals);
1312	1340
1313	1341	int
1314		-__group_send_sig_info(int sig, struct siginfo info, struct task_struct p)
	1342	+__group_send_sig_info(int sig, struct kernel_siginfo info, struct task_struct p)
1315	1343	{
1316	1344	return send_signal(sig, info, p, PIDTYPE_TGID);
1317	1345	}
1318	1346
1319		-static int
1320		-specific_send_sig_info(int sig, struct siginfo info, struct task_struct t)
1321		-{
1322		- return send_signal(sig, info, t, PIDTYPE_PID);
1323		-}
1324		-
1325		-int do_send_sig_info(int sig, struct siginfo info, struct task_struct p,
	1347	+int do_send_sig_info(int sig, struct kernel_siginfo info, struct task_struct p,
1326	1348	enum pid_type type)
1327	1349	{
1328	1350	unsigned long flags;
1329	1351	int ret = -ESRCH;
1330		-
	1352	+ trace_android_vh_do_send_sig_info(sig, current, p);
1331	1353	if (lock_task_sighand(p, &flags)) {
1332	1354	ret = send_signal(sig, info, p, type);
1333	1355	unlock_task_sighand(p, &flags);
..	..	@@ -1348,12 +1370,41 @@
1348	1370	* that is why we also clear SIGNAL_UNKILLABLE.
1349	1371	*/
1350	1372	static int
1351		-do_force_sig_info(int sig, struct siginfo info, struct task_struct t)
	1373	+force_sig_info_to_task(struct kernel_siginfo info, struct task_struct t)
1352	1374	{
1353	1375	unsigned long int flags;
1354	1376	int ret, blocked, ignored;
1355	1377	struct k_sigaction *action;
	1378	+ int sig = info->si_signo;
1356	1379
	1380	+ /*
	1381	+ * On some archs, PREEMPT_RT has to delay sending a signal from a trap
	1382	+ * since it can not enable preemption, and the signal code's spin_locks
	1383	+ * turn into mutexes. Instead, it must set TIF_NOTIFY_RESUME which will
	1384	+ * send the signal on exit of the trap.
	1385	+ */
	1386	+#ifdef ARCH_RT_DELAYS_SIGNAL_SEND
	1387	+ if (in_atomic()) {
	1388	+ struct task_struct *t = current;
	1389	+
	1390	+ if (WARN_ON_ONCE(t->forced_info.si_signo))
	1391	+ return 0;
	1392	+
	1393	+ if (is_si_special(info)) {
	1394	+ WARN_ON_ONCE(info != SEND_SIG_PRIV);
	1395	+ t->forced_info.si_signo = info->si_signo;
	1396	+ t->forced_info.si_errno = 0;
	1397	+ t->forced_info.si_code = SI_KERNEL;
	1398	+ t->forced_info.si_pid = 0;
	1399	+ t->forced_info.si_uid = 0;
	1400	+ } else {
	1401	+ t->forced_info = *info;
	1402	+ }
	1403	+
	1404	+ set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
	1405	+ return 0;
	1406	+ }
	1407	+#endif
1357	1408	spin_lock_irqsave(&t->sighand->siglock, flags);
1358	1409	action = &t->sighand->action[sig-1];
1359	1410	ignored = action->sa.sa_handler == SIG_IGN;
..	..	@@ -1371,43 +1422,15 @@
1371	1422	*/
1372	1423	if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1373	1424	t->signal->flags &= ~SIGNAL_UNKILLABLE;
1374		- ret = specific_send_sig_info(sig, info, t);
	1425	+ ret = send_signal(sig, info, t, PIDTYPE_PID);
1375	1426	spin_unlock_irqrestore(&t->sighand->siglock, flags);
1376	1427
1377	1428	return ret;
1378	1429	}
1379	1430
1380		-int force_sig_info(int sig, struct siginfo info, struct task_struct t)
	1431	+int force_sig_info(struct kernel_siginfo *info)
1381	1432	{
1382		-/*
1383		- * On some archs, PREEMPT_RT has to delay sending a signal from a trap
1384		- * since it can not enable preemption, and the signal code's spin_locks
1385		- * turn into mutexes. Instead, it must set TIF_NOTIFY_RESUME which will
1386		- * send the signal on exit of the trap.
1387		- */
1388		-#ifdef ARCH_RT_DELAYS_SIGNAL_SEND
1389		- if (in_atomic()) {
1390		- if (WARN_ON_ONCE(t != current))
1391		- return 0;
1392		- if (WARN_ON_ONCE(t->forced_info.si_signo))
1393		- return 0;
1394		-
1395		- if (is_si_special(info)) {
1396		- WARN_ON_ONCE(info != SEND_SIG_PRIV);
1397		- t->forced_info.si_signo = sig;
1398		- t->forced_info.si_errno = 0;
1399		- t->forced_info.si_code = SI_KERNEL;
1400		- t->forced_info.si_pid = 0;
1401		- t->forced_info.si_uid = 0;
1402		- } else {
1403		- t->forced_info = *info;
1404		- }
1405		-
1406		- set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
1407		- return 0;
1408		- }
1409		-#endif
1410		- return do_force_sig_info(sig, info, t);
	1433	+ return force_sig_info_to_task(info, current);
1411	1434	}
1412	1435
1413	1436	/*
..	..	@@ -1457,7 +1480,7 @@
1457	1480	* must see ->sighand == NULL.
1458	1481	*/
1459	1482	spin_lock_irqsave(&sighand->siglock, *flags);
1460		- if (likely(sighand == tsk->sighand))
	1483	+ if (likely(sighand == rcu_access_pointer(tsk->sighand)))
1461	1484	break;
1462	1485	spin_unlock_irqrestore(&sighand->siglock, *flags);
1463	1486	}
..	..	@@ -1469,8 +1492,8 @@
1469	1492	/*
1470	1493	* send signal info to all the members of a group
1471	1494	*/
1472		-int group_send_sig_info(int sig, struct siginfo info, struct task_struct p,
1473		- enum pid_type type)
	1495	+int group_send_sig_info(int sig, struct kernel_siginfo *info,
	1496	+ struct task_struct *p, enum pid_type type)
1474	1497	{
1475	1498	int ret;
1476	1499
..	..	@@ -1478,8 +1501,17 @@
1478	1501	ret = check_kill_permission(sig, info, p);
1479	1502	rcu_read_unlock();
1480	1503
1481		- if (!ret && sig)
	1504	+ if (!ret && sig) {
1482	1505	ret = do_send_sig_info(sig, info, p, type);
	1506	+ if (!ret && sig == SIGKILL) {
	1507	+ bool reap = false;
	1508	+
	1509	+ trace_android_vh_process_killed(current, &reap);
	1510	+ trace_android_vh_killed_process(current, p, &reap);
	1511	+ if (reap)
	1512	+ add_to_oom_reaper(p);
	1513	+ }
	1514	+ }
1483	1515
1484	1516	return ret;
1485	1517	}
..	..	@@ -1489,7 +1521,7 @@
1489	1521	* control characters do (^C, ^Z etc)
1490	1522	* - the caller must hold at least a readlock on tasklist_lock
1491	1523	*/
1492		-int __kill_pgrp_info(int sig, struct siginfo info, struct pid pgrp)
	1524	+int __kill_pgrp_info(int sig, struct kernel_siginfo info, struct pid pgrp)
1493	1525	{
1494	1526	struct task_struct *p = NULL;
1495	1527	int retval, success;
..	..	@@ -1504,7 +1536,7 @@
1504	1536	return success ? 0 : retval;
1505	1537	}
1506	1538
1507		-int kill_pid_info(int sig, struct siginfo info, struct pid pid)
	1539	+int kill_pid_info(int sig, struct kernel_siginfo info, struct pid pid)
1508	1540	{
1509	1541	int error = -ESRCH;
1510	1542	struct task_struct *p;
..	..	@@ -1526,7 +1558,7 @@
1526	1558	}
1527	1559	}
1528	1560
1529		-static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
	1561	+static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
1530	1562	{
1531	1563	int error;
1532	1564	rcu_read_lock();
..	..	@@ -1546,16 +1578,47 @@
1546	1578	uid_eq(cred->uid, pcred->uid);
1547	1579	}
1548	1580
1549		-/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1550		-int kill_pid_info_as_cred(int sig, struct siginfo info, struct pid pid,
1551		- const struct cred *cred)
	1581	+/*
	1582	+ * The usb asyncio usage of siginfo is wrong. The glibc support
	1583	+ * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT.
	1584	+ * AKA after the generic fields:
	1585	+ * kernel_pid_t si_pid;
	1586	+ * kernel_uid32_t si_uid;
	1587	+ * sigval_t si_value;
	1588	+ *
	1589	+ * Unfortunately when usb generates SI_ASYNCIO it assumes the layout
	1590	+ * after the generic fields is:
	1591	+ * void __user *si_addr;
	1592	+ *
	1593	+ * This is a practical problem when there is a 64bit big endian kernel
	1594	+ * and a 32bit userspace. As the 32bit address will encoded in the low
	1595	+ * 32bits of the pointer. Those low 32bits will be stored at higher
	1596	+ * address than appear in a 32 bit pointer. So userspace will not
	1597	+ * see the address it was expecting for it's completions.
	1598	+ *
	1599	+ * There is nothing in the encoding that can allow
	1600	+ * copy_siginfo_to_user32 to detect this confusion of formats, so
	1601	+ * handle this by requiring the caller of kill_pid_usb_asyncio to
	1602	+ * notice when this situration takes place and to store the 32bit
	1603	+ * pointer in sival_int, instead of sival_addr of the sigval_t addr
	1604	+ * parameter.
	1605	+ */
	1606	+int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr,
	1607	+ struct pid pid, const struct cred cred)
1552	1608	{
1553		- int ret = -EINVAL;
	1609	+ struct kernel_siginfo info;
1554	1610	struct task_struct *p;
1555	1611	unsigned long flags;
	1612	+ int ret = -EINVAL;
1556	1613
1557	1614	if (!valid_signal(sig))
1558	1615	return ret;
	1616	+
	1617	+ clear_siginfo(&info);
	1618	+ info.si_signo = sig;
	1619	+ info.si_errno = errno;
	1620	+ info.si_code = SI_ASYNCIO;
	1621	+ ((sigval_t )&info.si_pid) = addr;
1559	1622
1560	1623	rcu_read_lock();
1561	1624	p = pid_task(pid, PIDTYPE_PID);
..	..	@@ -1563,17 +1626,17 @@
1563	1626	ret = -ESRCH;
1564	1627	goto out_unlock;
1565	1628	}
1566		- if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
	1629	+ if (!kill_as_cred_perm(cred, p)) {
1567	1630	ret = -EPERM;
1568	1631	goto out_unlock;
1569	1632	}
1570		- ret = security_task_kill(p, info, sig, cred);
	1633	+ ret = security_task_kill(p, &info, sig, cred);
1571	1634	if (ret)
1572	1635	goto out_unlock;
1573	1636
1574	1637	if (sig) {
1575	1638	if (lock_task_sighand(p, &flags)) {
1576		- ret = __send_signal(sig, info, p, PIDTYPE_TGID, 0);
	1639	+ ret = __send_signal(sig, &info, p, PIDTYPE_TGID, false);
1577	1640	unlock_task_sighand(p, &flags);
1578	1641	} else
1579	1642	ret = -ESRCH;
..	..	@@ -1582,7 +1645,7 @@
1582	1645	rcu_read_unlock();
1583	1646	return ret;
1584	1647	}
1585		-EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
	1648	+EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio);
1586	1649
1587	1650	/*
1588	1651	* kill_something_info() interprets pid in interesting ways just like kill(2).
..	..	@@ -1591,16 +1654,12 @@
1591	1654	* is probably wrong. Should make it like BSD or SYSV.
1592	1655	*/
1593	1656
1594		-static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
	1657	+static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
1595	1658	{
1596	1659	int ret;
1597	1660
1598		- if (pid > 0) {
1599		- rcu_read_lock();
1600		- ret = kill_pid_info(sig, info, find_vpid(pid));
1601		- rcu_read_unlock();
1602		- return ret;
1603		- }
	1661	+ if (pid > 0)
	1662	+ return kill_proc_info(sig, info, pid);
1604	1663
1605	1664	/* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
1606	1665	if (pid == INT_MIN)
..	..	@@ -1635,7 +1694,7 @@
1635	1694	* These are for backward compatibility with the rest of the kernel source.
1636	1695	*/
1637	1696
1638		-int send_sig_info(int sig, struct siginfo info, struct task_struct p)
	1697	+int send_sig_info(int sig, struct kernel_siginfo info, struct task_struct p)
1639	1698	{
1640	1699	/*
1641	1700	* Make sure legacy kernel users don't send in bad values
..	..	@@ -1646,6 +1705,7 @@
1646	1705
1647	1706	return do_send_sig_info(sig, info, p, PIDTYPE_PID);
1648	1707	}
	1708	+EXPORT_SYMBOL(send_sig_info);
1649	1709
1650	1710	#define __si_special(priv) \
1651	1711	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
..	..	@@ -1655,11 +1715,21 @@
1655	1715	{
1656	1716	return send_sig_info(sig, __si_special(priv), p);
1657	1717	}
	1718	+EXPORT_SYMBOL(send_sig);
1658	1719
1659		-void force_sig(int sig, struct task_struct *p)
	1720	+void force_sig(int sig)
1660	1721	{
1661		- force_sig_info(sig, SEND_SIG_PRIV, p);
	1722	+ struct kernel_siginfo info;
	1723	+
	1724	+ clear_siginfo(&info);
	1725	+ info.si_signo = sig;
	1726	+ info.si_errno = 0;
	1727	+ info.si_code = SI_KERNEL;
	1728	+ info.si_pid = 0;
	1729	+ info.si_uid = 0;
	1730	+ force_sig_info(&info);
1662	1731	}
	1732	+EXPORT_SYMBOL(force_sig);
1663	1733
1664	1734	/*
1665	1735	* When things go south during signal handling, we
..	..	@@ -1667,23 +1737,25 @@
1667	1737	* the problem was already a SIGSEGV, we'll want to
1668	1738	* make sure we don't even try to deliver the signal..
1669	1739	*/
1670		-void force_sigsegv(int sig, struct task_struct *p)
	1740	+void force_sigsegv(int sig)
1671	1741	{
	1742	+ struct task_struct *p = current;
	1743	+
1672	1744	if (sig == SIGSEGV) {
1673	1745	unsigned long flags;
1674	1746	spin_lock_irqsave(&p->sighand->siglock, flags);
1675	1747	p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1676	1748	spin_unlock_irqrestore(&p->sighand->siglock, flags);
1677	1749	}
1678		- force_sig(SIGSEGV, p);
	1750	+ force_sig(SIGSEGV);
1679	1751	}
1680	1752
1681		-int force_sig_fault(int sig, int code, void __user *addr
	1753	+int force_sig_fault_to_task(int sig, int code, void __user *addr
1682	1754	___ARCH_SI_TRAPNO(int trapno)
1683	1755	___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1684	1756	, struct task_struct *t)
1685	1757	{
1686		- struct siginfo info;
	1758	+ struct kernel_siginfo info;
1687	1759
1688	1760	clear_siginfo(&info);
1689	1761	info.si_signo = sig;
..	..	@@ -1698,7 +1770,16 @@
1698	1770	info.si_flags = flags;
1699	1771	info.si_isr = isr;
1700	1772	#endif
1701		- return force_sig_info(info.si_signo, &info, t);
	1773	+ return force_sig_info_to_task(&info, t);
	1774	+}
	1775	+
	1776	+int force_sig_fault(int sig, int code, void __user *addr
	1777	+ ___ARCH_SI_TRAPNO(int trapno)
	1778	+ ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr))
	1779	+{
	1780	+ return force_sig_fault_to_task(sig, code, addr
	1781	+ ___ARCH_SI_TRAPNO(trapno)
	1782	+ ___ARCH_SI_IA64(imm, flags, isr), current);
1702	1783	}
1703	1784
1704	1785	int send_sig_fault(int sig, int code, void __user *addr
..	..	@@ -1706,7 +1787,7 @@
1706	1787	___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1707	1788	, struct task_struct *t)
1708	1789	{
1709		- struct siginfo info;
	1790	+ struct kernel_siginfo info;
1710	1791
1711	1792	clear_siginfo(&info);
1712	1793	info.si_signo = sig;
..	..	@@ -1724,9 +1805,9 @@
1724	1805	return send_sig_info(info.si_signo, &info, t);
1725	1806	}
1726	1807
1727		-int force_sig_mceerr(int code, void __user addr, short lsb, struct task_struct t)
	1808	+int force_sig_mceerr(int code, void __user *addr, short lsb)
1728	1809	{
1729		- struct siginfo info;
	1810	+ struct kernel_siginfo info;
1730	1811
1731	1812	WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1732	1813	clear_siginfo(&info);
..	..	@@ -1735,12 +1816,12 @@
1735	1816	info.si_code = code;
1736	1817	info.si_addr = addr;
1737	1818	info.si_addr_lsb = lsb;
1738		- return force_sig_info(info.si_signo, &info, t);
	1819	+ return force_sig_info(&info);
1739	1820	}
1740	1821
1741	1822	int send_sig_mceerr(int code, void __user addr, short lsb, struct task_struct t)
1742	1823	{
1743		- struct siginfo info;
	1824	+ struct kernel_siginfo info;
1744	1825
1745	1826	WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1746	1827	clear_siginfo(&info);
..	..	@@ -1755,7 +1836,7 @@
1755	1836
1756	1837	int force_sig_bnderr(void __user addr, void __user lower, void __user *upper)
1757	1838	{
1758		- struct siginfo info;
	1839	+ struct kernel_siginfo info;
1759	1840
1760	1841	clear_siginfo(&info);
1761	1842	info.si_signo = SIGSEGV;
..	..	@@ -1764,13 +1845,13 @@
1764	1845	info.si_addr = addr;
1765	1846	info.si_lower = lower;
1766	1847	info.si_upper = upper;
1767		- return force_sig_info(info.si_signo, &info, current);
	1848	+ return force_sig_info(&info);
1768	1849	}
1769	1850
1770	1851	#ifdef SEGV_PKUERR
1771	1852	int force_sig_pkuerr(void __user *addr, u32 pkey)
1772	1853	{
1773		- struct siginfo info;
	1854	+ struct kernel_siginfo info;
1774	1855
1775	1856	clear_siginfo(&info);
1776	1857	info.si_signo = SIGSEGV;
..	..	@@ -1778,7 +1859,7 @@
1778	1859	info.si_code = SEGV_PKUERR;
1779	1860	info.si_addr = addr;
1780	1861	info.si_pkey = pkey;
1781		- return force_sig_info(info.si_signo, &info, current);
	1862	+ return force_sig_info(&info);
1782	1863	}
1783	1864	#endif
1784	1865
..	..	@@ -1787,14 +1868,14 @@
1787	1868	*/
1788	1869	int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1789	1870	{
1790		- struct siginfo info;
	1871	+ struct kernel_siginfo info;
1791	1872
1792	1873	clear_siginfo(&info);
1793	1874	info.si_signo = SIGTRAP;
1794	1875	info.si_errno = errno;
1795	1876	info.si_code = TRAP_HWBKPT;
1796	1877	info.si_addr = addr;
1797		- return force_sig_info(info.si_signo, &info, current);
	1878	+ return force_sig_info(&info);
1798	1879	}
1799	1880
1800	1881	int kill_pgrp(struct pid *pid, int sig, int priv)
..	..	@@ -1912,6 +1993,7 @@
1912	1993	{
1913	1994	struct pid *pid;
1914	1995
	1996	+ WARN_ON(task->exit_state == 0);
1915	1997	pid = task_pid(task);
1916	1998	wake_up_all(&pid->wait_pidfd);
1917	1999	}
..	..	@@ -1925,18 +2007,18 @@
1925	2007	*/
1926	2008	bool do_notify_parent(struct task_struct *tsk, int sig)
1927	2009	{
1928		- struct siginfo info;
	2010	+ struct kernel_siginfo info;
1929	2011	unsigned long flags;
1930	2012	struct sighand_struct *psig;
1931	2013	bool autoreap = false;
1932	2014	u64 utime, stime;
1933	2015
1934		- BUG_ON(sig == -1);
	2016	+ WARN_ON_ONCE(sig == -1);
1935	2017
1936		- /* do_notify_parent_cldstop should have been called instead. */
1937		- BUG_ON(task_is_stopped_or_traced(tsk));
	2018	+ /* do_notify_parent_cldstop should have been called instead. */
	2019	+ WARN_ON_ONCE(task_is_stopped_or_traced(tsk));
1938	2020
1939		- BUG_ON(!tsk->ptrace &&
	2021	+ WARN_ON_ONCE(!tsk->ptrace &&
1940	2022	(tsk->group_leader != tsk \|\| !thread_group_empty(tsk)));
1941	2023
1942	2024	/* Wake up all pidfd waiters */
..	..	@@ -2009,8 +2091,12 @@
2009	2091	if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
2010	2092	sig = 0;
2011	2093	}
	2094	+ /*
	2095	+ * Send with __send_signal as si_pid and si_uid are in the
	2096	+ * parent's namespaces.
	2097	+ */
2012	2098	if (valid_signal(sig) && sig)
2013		- __group_send_sig_info(sig, &info, tsk->parent);
	2099	+ __send_signal(sig, &info, tsk->parent, PIDTYPE_TGID, false);
2014	2100	__wake_up_parent(tsk, tsk->parent);
2015	2101	spin_unlock_irqrestore(&psig->siglock, flags);
2016	2102
..	..	@@ -2033,7 +2119,7 @@
2033	2119	static void do_notify_parent_cldstop(struct task_struct *tsk,
2034	2120	bool for_ptracer, int why)
2035	2121	{
2036		- struct siginfo info;
	2122	+ struct kernel_siginfo info;
2037	2123	unsigned long flags;
2038	2124	struct task_struct *parent;
2039	2125	struct sighand_struct *sighand;
..	..	@@ -2124,7 +2210,7 @@
2124	2210	* If we actually decide not to stop at all because the tracer
2125	2211	* is gone, we keep current->exit_code unless clear_code.
2126	2212	*/
2127		-static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
	2213	+static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info)
2128	2214	__releases(&current->sighand->siglock)
2129	2215	__acquires(&current->sighand->siglock)
2130	2216	{
..	..	@@ -2209,7 +2295,9 @@
2209	2295	do_notify_parent_cldstop(current, false, why);
2210	2296
2211	2297	read_unlock(&tasklist_lock);
	2298	+ cgroup_enter_frozen();
2212	2299	freezable_schedule();
	2300	+ cgroup_leave_frozen(true);
2213	2301	} else {
2214	2302	/*
2215	2303	* By the time we got the lock, our tracer went away.
..	..	@@ -2252,7 +2340,7 @@
2252	2340
2253	2341	static void ptrace_do_notify(int signr, int exit_code, int why)
2254	2342	{
2255		- siginfo_t info;
	2343	+ kernel_siginfo_t info;
2256	2344
2257	2345	clear_siginfo(&info);
2258	2346	info.si_signo = signr;
..	..	@@ -2471,7 +2559,7 @@
2471	2559	freezable_schedule();
2472	2560	}
2473	2561
2474		-static int ptrace_signal(int signr, siginfo_t *info)
	2562	+static int ptrace_signal(int signr, kernel_siginfo_t *info)
2475	2563	{
2476	2564	/*
2477	2565	* We do not check sig_kernel_stop(signr) but set this marker
..	..	@@ -2512,11 +2600,31 @@
2512	2600
2513	2601	/* If the (new) signal is now blocked, requeue it. */
2514	2602	if (sigismember(&current->blocked, signr)) {
2515		- specific_send_sig_info(signr, info, current);
	2603	+ send_signal(signr, info, current, PIDTYPE_PID);
2516	2604	signr = 0;
2517	2605	}
2518	2606
2519	2607	return signr;
	2608	+}
	2609	+
	2610	+static void hide_si_addr_tag_bits(struct ksignal *ksig)
	2611	+{
	2612	+ switch (siginfo_layout(ksig->sig, ksig->info.si_code)) {
	2613	+ case SIL_FAULT:
	2614	+ case SIL_FAULT_MCEERR:
	2615	+ case SIL_FAULT_BNDERR:
	2616	+ case SIL_FAULT_PKUERR:
	2617	+ ksig->info.si_addr = arch_untagged_si_addr(
	2618	+ ksig->info.si_addr, ksig->sig, ksig->info.si_code);
	2619	+ break;
	2620	+ case SIL_KILL:
	2621	+ case SIL_TIMER:
	2622	+ case SIL_POLL:
	2623	+ case SIL_CHLD:
	2624	+ case SIL_RT:
	2625	+ case SIL_SYS:
	2626	+ break;
	2627	+ }
2520	2628	}
2521	2629
2522	2630	bool get_signal(struct ksignal *ksig)
..	..	@@ -2527,6 +2635,18 @@
2527	2635
2528	2636	if (unlikely(current->task_works))
2529	2637	task_work_run();
	2638	+
	2639	+ /*
	2640	+ * For non-generic architectures, check for TIF_NOTIFY_SIGNAL so
	2641	+ * that the arch handlers don't all have to do it. If we get here
	2642	+ * without TIF_SIGPENDING, just exit after running signal work.
	2643	+ */
	2644	+ if (!IS_ENABLED(CONFIG_GENERIC_ENTRY)) {
	2645	+ if (test_thread_flag(TIF_NOTIFY_SIGNAL))
	2646	+ tracehook_notify_signal();
	2647	+ if (!task_sigpending(current))
	2648	+ return false;
	2649	+ }
2530	2650
2531	2651	if (unlikely(uprobe_deny_signal()))
2532	2652	return false;
..	..	@@ -2540,6 +2660,7 @@
2540	2660
2541	2661	relock:
2542	2662	spin_lock_irq(&sighand->siglock);
	2663	+
2543	2664	/*
2544	2665	* Every stopped thread goes here after wakeup. Check to see if
2545	2666	* we should notify the parent, prepare_signal(SIGCONT) encodes
..	..	@@ -2583,10 +2704,6 @@
2583	2704	trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO,
2584	2705	&sighand->action[SIGKILL - 1]);
2585	2706	recalc_sigpending();
2586		- current->jobctl &= ~JOBCTL_TRAP_FREEZE;
2587		- spin_unlock_irq(&sighand->siglock);
2588		- if (unlikely(cgroup_task_frozen(current)))
2589		- cgroup_leave_frozen(true);
2590	2707	goto fatal;
2591	2708	}
2592	2709
..	..	@@ -2614,7 +2731,7 @@
2614	2731	*/
2615	2732	if (unlikely(cgroup_task_frozen(current))) {
2616	2733	spin_unlock_irq(&sighand->siglock);
2617		- cgroup_leave_frozen(true);
	2734	+ cgroup_leave_frozen(false);
2618	2735	goto relock;
2619	2736	}
2620	2737
..	..	@@ -2708,8 +2825,10 @@
2708	2825	continue;
2709	2826	}
2710	2827
2711		- spin_unlock_irq(&sighand->siglock);
2712	2828	fatal:
	2829	+ spin_unlock_irq(&sighand->siglock);
	2830	+ if (unlikely(cgroup_task_frozen(current)))
	2831	+ cgroup_leave_frozen(true);
2713	2832
2714	2833	/*
2715	2834	* Anything else is fatal, maybe with a core dump.
..	..	@@ -2732,14 +2851,26 @@
2732	2851	}
2733	2852
2734	2853	/*
	2854	+ * PF_IO_WORKER threads will catch and exit on fatal signals
	2855	+ * themselves. They have cleanup that must be performed, so
	2856	+ * we cannot call do_exit() on their behalf.
	2857	+ */
	2858	+ if (current->flags & PF_IO_WORKER)
	2859	+ goto out;
	2860	+
	2861	+ /*
2735	2862	* Death signals, no core dump.
2736	2863	*/
2737	2864	do_group_exit(ksig->info.si_signo);
2738	2865	/* NOTREACHED */
2739	2866	}
2740	2867	spin_unlock_irq(&sighand->siglock);
2741		-
	2868	+out:
2742	2869	ksig->sig = signr;
	2870	+
	2871	+ if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))
	2872	+ hide_si_addr_tag_bits(ksig);
	2873	+
2743	2874	return ksig->sig > 0;
2744	2875	}
2745	2876
..	..	@@ -2773,7 +2904,7 @@
2773	2904	void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2774	2905	{
2775	2906	if (failed)
2776		- force_sigsegv(ksig->sig, current);
	2907	+ force_sigsegv(ksig->sig);
2777	2908	else
2778	2909	signal_delivered(ksig, stepping);
2779	2910	}
..	..	@@ -2802,7 +2933,7 @@
2802	2933	/* Remove the signals this thread can handle. */
2803	2934	sigandsets(&retarget, &retarget, &t->blocked);
2804	2935
2805		- if (!signal_pending(t))
	2936	+ if (!task_sigpending(t))
2806	2937	signal_wake_up(t, 0);
2807	2938
2808	2939	if (sigisemptyset(&retarget))
..	..	@@ -2836,7 +2967,7 @@
2836	2967
2837	2968	cgroup_threadgroup_change_end(tsk);
2838	2969
2839		- if (!signal_pending(tsk))
	2970	+ if (!task_sigpending(tsk))
2840	2971	goto out;
2841	2972
2842	2973	unblocked = tsk->blocked;
..	..	@@ -2860,14 +2991,6 @@
2860	2991	}
2861	2992	}
2862	2993
2863		-EXPORT_SYMBOL(recalc_sigpending);
2864		-EXPORT_SYMBOL_GPL(dequeue_signal);
2865		-EXPORT_SYMBOL(flush_signals);
2866		-EXPORT_SYMBOL(force_sig);
2867		-EXPORT_SYMBOL(send_sig);
2868		-EXPORT_SYMBOL(send_sig_info);
2869		-EXPORT_SYMBOL(sigprocmask);
2870		-
2871	2994	/*
2872	2995	* System call entry points.
2873	2996	*/
..	..	@@ -2888,7 +3011,7 @@
2888	3011
2889	3012	static void __set_task_blocked(struct task_struct tsk, const sigset_t newset)
2890	3013	{
2891		- if (signal_pending(tsk) && !thread_group_empty(tsk)) {
	3014	+ if (task_sigpending(tsk) && !thread_group_empty(tsk)) {
2892	3015	sigset_t newblocked;
2893	3016	/* A set of now blocked but previously unblocked signals. */
2894	3017	sigandnsets(&newblocked, newset, &current->blocked);
..	..	@@ -2961,6 +3084,55 @@
2961	3084	__set_current_blocked(&newset);
2962	3085	return 0;
2963	3086	}
	3087	+EXPORT_SYMBOL(sigprocmask);
	3088	+
	3089	+/*
	3090	+ * The api helps set app-provided sigmasks.
	3091	+ *
	3092	+ * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
	3093	+ * epoll_pwait where a new sigmask is passed from userland for the syscalls.
	3094	+ *
	3095	+ * Note that it does set_restore_sigmask() in advance, so it must be always
	3096	+ * paired with restore_saved_sigmask_unless() before return from syscall.
	3097	+ */
	3098	+int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
	3099	+{
	3100	+ sigset_t kmask;
	3101	+
	3102	+ if (!umask)
	3103	+ return 0;
	3104	+ if (sigsetsize != sizeof(sigset_t))
	3105	+ return -EINVAL;
	3106	+ if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
	3107	+ return -EFAULT;
	3108	+
	3109	+ set_restore_sigmask();
	3110	+ current->saved_sigmask = current->blocked;
	3111	+ set_current_blocked(&kmask);
	3112	+
	3113	+ return 0;
	3114	+}
	3115	+
	3116	+#ifdef CONFIG_COMPAT
	3117	+int set_compat_user_sigmask(const compat_sigset_t __user *umask,
	3118	+ size_t sigsetsize)
	3119	+{
	3120	+ sigset_t kmask;
	3121	+
	3122	+ if (!umask)
	3123	+ return 0;
	3124	+ if (sigsetsize != sizeof(compat_sigset_t))
	3125	+ return -EINVAL;
	3126	+ if (get_compat_sigset(&kmask, umask))
	3127	+ return -EFAULT;
	3128	+
	3129	+ set_restore_sigmask();
	3130	+ current->saved_sigmask = current->blocked;
	3131	+ set_current_blocked(&kmask);
	3132	+
	3133	+ return 0;
	3134	+}
	3135	+#endif
2964	3136
2965	3137	/**
2966	3138	* sys_rt_sigprocmask - change the list of currently blocked signals
..	..	@@ -3071,27 +3243,48 @@
3071	3243	}
3072	3244	#endif
3073	3245
	3246	+static const struct {
	3247	+ unsigned char limit, layout;
	3248	+} sig_sicodes[] = {
	3249	+ [SIGILL] = { NSIGILL, SIL_FAULT },
	3250	+ [SIGFPE] = { NSIGFPE, SIL_FAULT },
	3251	+ [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
	3252	+ [SIGBUS] = { NSIGBUS, SIL_FAULT },
	3253	+ [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
	3254	+#if defined(SIGEMT)
	3255	+ [SIGEMT] = { NSIGEMT, SIL_FAULT },
	3256	+#endif
	3257	+ [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
	3258	+ [SIGPOLL] = { NSIGPOLL, SIL_POLL },
	3259	+ [SIGSYS] = { NSIGSYS, SIL_SYS },
	3260	+};
	3261	+
	3262	+static bool known_siginfo_layout(unsigned sig, int si_code)
	3263	+{
	3264	+ if (si_code == SI_KERNEL)
	3265	+ return true;
	3266	+ else if ((si_code > SI_USER)) {
	3267	+ if (sig_specific_sicodes(sig)) {
	3268	+ if (si_code <= sig_sicodes[sig].limit)
	3269	+ return true;
	3270	+ }
	3271	+ else if (si_code <= NSIGPOLL)
	3272	+ return true;
	3273	+ }
	3274	+ else if (si_code >= SI_DETHREAD)
	3275	+ return true;
	3276	+ else if (si_code == SI_ASYNCNL)
	3277	+ return true;
	3278	+ return false;
	3279	+}
	3280	+
3074	3281	enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
3075	3282	{
3076	3283	enum siginfo_layout layout = SIL_KILL;
3077	3284	if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
3078		- static const struct {
3079		- unsigned char limit, layout;
3080		- } filter[] = {
3081		- [SIGILL] = { NSIGILL, SIL_FAULT },
3082		- [SIGFPE] = { NSIGFPE, SIL_FAULT },
3083		- [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
3084		- [SIGBUS] = { NSIGBUS, SIL_FAULT },
3085		- [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
3086		-#if defined(SIGEMT) && defined(NSIGEMT)
3087		- [SIGEMT] = { NSIGEMT, SIL_FAULT },
3088		-#endif
3089		- [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
3090		- [SIGPOLL] = { NSIGPOLL, SIL_POLL },
3091		- [SIGSYS] = { NSIGSYS, SIL_SYS },
3092		- };
3093		- if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit)) {
3094		- layout = filter[sig].layout;
	3285	+ if ((sig < ARRAY_SIZE(sig_sicodes)) &&
	3286	+ (si_code <= sig_sicodes[sig].limit)) {
	3287	+ layout = sig_sicodes[sig].layout;
3095	3288	/* Handle the exceptions */
3096	3289	if ((sig == SIGBUS) &&
3097	3290	(si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
..	..	@@ -3116,106 +3309,243 @@
3116	3309	return layout;
3117	3310	}
3118	3311
3119		-int copy_siginfo_to_user(siginfo_t __user to, const siginfo_t from)
	3312	+static inline char __user si_expansion(const siginfo_t __user info)
3120	3313	{
3121		- if (copy_to_user(to, from , sizeof(struct siginfo)))
	3314	+ return ((char __user *)info) + sizeof(struct kernel_siginfo);
	3315	+}
	3316	+
	3317	+int copy_siginfo_to_user(siginfo_t __user to, const kernel_siginfo_t from)
	3318	+{
	3319	+ char __user *expansion = si_expansion(to);
	3320	+ if (copy_to_user(to, from , sizeof(struct kernel_siginfo)))
	3321	+ return -EFAULT;
	3322	+ if (clear_user(expansion, SI_EXPANSION_SIZE))
3122	3323	return -EFAULT;
3123	3324	return 0;
	3325	+}
	3326	+
	3327	+static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
	3328	+ const siginfo_t __user *from)
	3329	+{
	3330	+ if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) {
	3331	+ char __user *expansion = si_expansion(from);
	3332	+ char buf[SI_EXPANSION_SIZE];
	3333	+ int i;
	3334	+ /*
	3335	+ * An unknown si_code might need more than
	3336	+ * sizeof(struct kernel_siginfo) bytes. Verify all of the
	3337	+ * extra bytes are 0. This guarantees copy_siginfo_to_user
	3338	+ * will return this data to userspace exactly.
	3339	+ */
	3340	+ if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
	3341	+ return -EFAULT;
	3342	+ for (i = 0; i < SI_EXPANSION_SIZE; i++) {
	3343	+ if (buf[i] != 0)
	3344	+ return -E2BIG;
	3345	+ }
	3346	+ }
	3347	+ return 0;
	3348	+}
	3349	+
	3350	+static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
	3351	+ const siginfo_t __user *from)
	3352	+{
	3353	+ if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
	3354	+ return -EFAULT;
	3355	+ to->si_signo = signo;
	3356	+ return post_copy_siginfo_from_user(to, from);
	3357	+}
	3358	+
	3359	+int copy_siginfo_from_user(kernel_siginfo_t to, const siginfo_t __user from)
	3360	+{
	3361	+ if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
	3362	+ return -EFAULT;
	3363	+ return post_copy_siginfo_from_user(to, from);
3124	3364	}
3125	3365
3126	3366	#ifdef CONFIG_COMPAT
3127		-int copy_siginfo_to_user32(struct compat_siginfo __user *to,
3128		- const struct siginfo *from)
3129		-#if defined(CONFIG_X86_X32_ABI) \|\| defined(CONFIG_IA32_EMULATION)
	3367	+/**
	3368	+ * copy_siginfo_to_external32 - copy a kernel siginfo into a compat user siginfo
	3369	+ * @to: compat siginfo destination
	3370	+ * @from: kernel siginfo source
	3371	+ *
	3372	+ * Note: This function does not work properly for the SIGCHLD on x32, but
	3373	+ * fortunately it doesn't have to. The only valid callers for this function are
	3374	+ * copy_siginfo_to_user32, which is overriden for x32 and the coredump code.
	3375	+ * The latter does not care because SIGCHLD will never cause a coredump.
	3376	+ */
	3377	+void copy_siginfo_to_external32(struct compat_siginfo *to,
	3378	+ const struct kernel_siginfo *from)
3130	3379	{
3131		- return __copy_siginfo_to_user32(to, from, in_x32_syscall());
3132		-}
3133		-int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
3134		- const struct siginfo *from, bool x32_ABI)
3135		-#endif
3136		-{
3137		- struct compat_siginfo new;
3138		- memset(&new, 0, sizeof(new));
	3380	+ memset(to, 0, sizeof(*to));
3139	3381
3140		- new.si_signo = from->si_signo;
3141		- new.si_errno = from->si_errno;
3142		- new.si_code = from->si_code;
	3382	+ to->si_signo = from->si_signo;
	3383	+ to->si_errno = from->si_errno;
	3384	+ to->si_code = from->si_code;
3143	3385	switch(siginfo_layout(from->si_signo, from->si_code)) {
3144	3386	case SIL_KILL:
3145		- new.si_pid = from->si_pid;
3146		- new.si_uid = from->si_uid;
	3387	+ to->si_pid = from->si_pid;
	3388	+ to->si_uid = from->si_uid;
3147	3389	break;
3148	3390	case SIL_TIMER:
3149		- new.si_tid = from->si_tid;
3150		- new.si_overrun = from->si_overrun;
3151		- new.si_int = from->si_int;
	3391	+ to->si_tid = from->si_tid;
	3392	+ to->si_overrun = from->si_overrun;
	3393	+ to->si_int = from->si_int;
3152	3394	break;
3153	3395	case SIL_POLL:
3154		- new.si_band = from->si_band;
3155		- new.si_fd = from->si_fd;
	3396	+ to->si_band = from->si_band;
	3397	+ to->si_fd = from->si_fd;
3156	3398	break;
3157	3399	case SIL_FAULT:
3158		- new.si_addr = ptr_to_compat(from->si_addr);
	3400	+ to->si_addr = ptr_to_compat(from->si_addr);
3159	3401	#ifdef __ARCH_SI_TRAPNO
3160		- new.si_trapno = from->si_trapno;
	3402	+ to->si_trapno = from->si_trapno;
3161	3403	#endif
3162	3404	break;
3163	3405	case SIL_FAULT_MCEERR:
3164		- new.si_addr = ptr_to_compat(from->si_addr);
	3406	+ to->si_addr = ptr_to_compat(from->si_addr);
3165	3407	#ifdef __ARCH_SI_TRAPNO
3166		- new.si_trapno = from->si_trapno;
	3408	+ to->si_trapno = from->si_trapno;
3167	3409	#endif
3168		- new.si_addr_lsb = from->si_addr_lsb;
	3410	+ to->si_addr_lsb = from->si_addr_lsb;
3169	3411	break;
3170	3412	case SIL_FAULT_BNDERR:
3171		- new.si_addr = ptr_to_compat(from->si_addr);
	3413	+ to->si_addr = ptr_to_compat(from->si_addr);
3172	3414	#ifdef __ARCH_SI_TRAPNO
3173		- new.si_trapno = from->si_trapno;
	3415	+ to->si_trapno = from->si_trapno;
3174	3416	#endif
3175		- new.si_lower = ptr_to_compat(from->si_lower);
3176		- new.si_upper = ptr_to_compat(from->si_upper);
	3417	+ to->si_lower = ptr_to_compat(from->si_lower);
	3418	+ to->si_upper = ptr_to_compat(from->si_upper);
3177	3419	break;
3178	3420	case SIL_FAULT_PKUERR:
3179		- new.si_addr = ptr_to_compat(from->si_addr);
	3421	+ to->si_addr = ptr_to_compat(from->si_addr);
3180	3422	#ifdef __ARCH_SI_TRAPNO
3181		- new.si_trapno = from->si_trapno;
	3423	+ to->si_trapno = from->si_trapno;
3182	3424	#endif
3183		- new.si_pkey = from->si_pkey;
	3425	+ to->si_pkey = from->si_pkey;
3184	3426	break;
3185	3427	case SIL_CHLD:
3186		- new.si_pid = from->si_pid;
3187		- new.si_uid = from->si_uid;
3188		- new.si_status = from->si_status;
3189		-#ifdef CONFIG_X86_X32_ABI
3190		- if (x32_ABI) {
3191		- new._sifields._sigchld_x32._utime = from->si_utime;
3192		- new._sifields._sigchld_x32._stime = from->si_stime;
3193		- } else
3194		-#endif
3195		- {
3196		- new.si_utime = from->si_utime;
3197		- new.si_stime = from->si_stime;
3198		- }
	3428	+ to->si_pid = from->si_pid;
	3429	+ to->si_uid = from->si_uid;
	3430	+ to->si_status = from->si_status;
	3431	+ to->si_utime = from->si_utime;
	3432	+ to->si_stime = from->si_stime;
3199	3433	break;
3200	3434	case SIL_RT:
3201		- new.si_pid = from->si_pid;
3202		- new.si_uid = from->si_uid;
3203		- new.si_int = from->si_int;
	3435	+ to->si_pid = from->si_pid;
	3436	+ to->si_uid = from->si_uid;
	3437	+ to->si_int = from->si_int;
3204	3438	break;
3205	3439	case SIL_SYS:
3206		- new.si_call_addr = ptr_to_compat(from->si_call_addr);
3207		- new.si_syscall = from->si_syscall;
3208		- new.si_arch = from->si_arch;
	3440	+ to->si_call_addr = ptr_to_compat(from->si_call_addr);
	3441	+ to->si_syscall = from->si_syscall;
	3442	+ to->si_arch = from->si_arch;
3209	3443	break;
3210	3444	}
	3445	+}
3211	3446
	3447	+int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
	3448	+ const struct kernel_siginfo *from)
	3449	+{
	3450	+ struct compat_siginfo new;
	3451	+
	3452	+ copy_siginfo_to_external32(&new, from);
3212	3453	if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
3213	3454	return -EFAULT;
3214		-
3215	3455	return 0;
3216	3456	}
3217	3457
3218		-int copy_siginfo_from_user32(struct siginfo *to,
	3458	+static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
	3459	+ const struct compat_siginfo *from)
	3460	+{
	3461	+ clear_siginfo(to);
	3462	+ to->si_signo = from->si_signo;
	3463	+ to->si_errno = from->si_errno;
	3464	+ to->si_code = from->si_code;
	3465	+ switch(siginfo_layout(from->si_signo, from->si_code)) {
	3466	+ case SIL_KILL:
	3467	+ to->si_pid = from->si_pid;
	3468	+ to->si_uid = from->si_uid;
	3469	+ break;
	3470	+ case SIL_TIMER:
	3471	+ to->si_tid = from->si_tid;
	3472	+ to->si_overrun = from->si_overrun;
	3473	+ to->si_int = from->si_int;
	3474	+ break;
	3475	+ case SIL_POLL:
	3476	+ to->si_band = from->si_band;
	3477	+ to->si_fd = from->si_fd;
	3478	+ break;
	3479	+ case SIL_FAULT:
	3480	+ to->si_addr = compat_ptr(from->si_addr);
	3481	+#ifdef __ARCH_SI_TRAPNO
	3482	+ to->si_trapno = from->si_trapno;
	3483	+#endif
	3484	+ break;
	3485	+ case SIL_FAULT_MCEERR:
	3486	+ to->si_addr = compat_ptr(from->si_addr);
	3487	+#ifdef __ARCH_SI_TRAPNO
	3488	+ to->si_trapno = from->si_trapno;
	3489	+#endif
	3490	+ to->si_addr_lsb = from->si_addr_lsb;
	3491	+ break;
	3492	+ case SIL_FAULT_BNDERR:
	3493	+ to->si_addr = compat_ptr(from->si_addr);
	3494	+#ifdef __ARCH_SI_TRAPNO
	3495	+ to->si_trapno = from->si_trapno;
	3496	+#endif
	3497	+ to->si_lower = compat_ptr(from->si_lower);
	3498	+ to->si_upper = compat_ptr(from->si_upper);
	3499	+ break;
	3500	+ case SIL_FAULT_PKUERR:
	3501	+ to->si_addr = compat_ptr(from->si_addr);
	3502	+#ifdef __ARCH_SI_TRAPNO
	3503	+ to->si_trapno = from->si_trapno;
	3504	+#endif
	3505	+ to->si_pkey = from->si_pkey;
	3506	+ break;
	3507	+ case SIL_CHLD:
	3508	+ to->si_pid = from->si_pid;
	3509	+ to->si_uid = from->si_uid;
	3510	+ to->si_status = from->si_status;
	3511	+#ifdef CONFIG_X86_X32_ABI
	3512	+ if (in_x32_syscall()) {
	3513	+ to->si_utime = from->_sifields._sigchld_x32._utime;
	3514	+ to->si_stime = from->_sifields._sigchld_x32._stime;
	3515	+ } else
	3516	+#endif
	3517	+ {
	3518	+ to->si_utime = from->si_utime;
	3519	+ to->si_stime = from->si_stime;
	3520	+ }
	3521	+ break;
	3522	+ case SIL_RT:
	3523	+ to->si_pid = from->si_pid;
	3524	+ to->si_uid = from->si_uid;
	3525	+ to->si_int = from->si_int;
	3526	+ break;
	3527	+ case SIL_SYS:
	3528	+ to->si_call_addr = compat_ptr(from->si_call_addr);
	3529	+ to->si_syscall = from->si_syscall;
	3530	+ to->si_arch = from->si_arch;
	3531	+ break;
	3532	+ }
	3533	+ return 0;
	3534	+}
	3535	+
	3536	+static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
	3537	+ const struct compat_siginfo __user *ufrom)
	3538	+{
	3539	+ struct compat_siginfo from;
	3540	+
	3541	+ if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
	3542	+ return -EFAULT;
	3543	+
	3544	+ from.si_signo = signo;
	3545	+ return post_copy_siginfo_from_user32(to, &from);
	3546	+}
	3547	+
	3548	+int copy_siginfo_from_user32(struct kernel_siginfo *to,
3219	3549	const struct compat_siginfo __user *ufrom)
3220	3550	{
3221	3551	struct compat_siginfo from;
..	..	@@ -3223,79 +3553,7 @@
3223	3553	if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3224	3554	return -EFAULT;
3225	3555
3226		- clear_siginfo(to);
3227		- to->si_signo = from.si_signo;
3228		- to->si_errno = from.si_errno;
3229		- to->si_code = from.si_code;
3230		- switch(siginfo_layout(from.si_signo, from.si_code)) {
3231		- case SIL_KILL:
3232		- to->si_pid = from.si_pid;
3233		- to->si_uid = from.si_uid;
3234		- break;
3235		- case SIL_TIMER:
3236		- to->si_tid = from.si_tid;
3237		- to->si_overrun = from.si_overrun;
3238		- to->si_int = from.si_int;
3239		- break;
3240		- case SIL_POLL:
3241		- to->si_band = from.si_band;
3242		- to->si_fd = from.si_fd;
3243		- break;
3244		- case SIL_FAULT:
3245		- to->si_addr = compat_ptr(from.si_addr);
3246		-#ifdef __ARCH_SI_TRAPNO
3247		- to->si_trapno = from.si_trapno;
3248		-#endif
3249		- break;
3250		- case SIL_FAULT_MCEERR:
3251		- to->si_addr = compat_ptr(from.si_addr);
3252		-#ifdef __ARCH_SI_TRAPNO
3253		- to->si_trapno = from.si_trapno;
3254		-#endif
3255		- to->si_addr_lsb = from.si_addr_lsb;
3256		- break;
3257		- case SIL_FAULT_BNDERR:
3258		- to->si_addr = compat_ptr(from.si_addr);
3259		-#ifdef __ARCH_SI_TRAPNO
3260		- to->si_trapno = from.si_trapno;
3261		-#endif
3262		- to->si_lower = compat_ptr(from.si_lower);
3263		- to->si_upper = compat_ptr(from.si_upper);
3264		- break;
3265		- case SIL_FAULT_PKUERR:
3266		- to->si_addr = compat_ptr(from.si_addr);
3267		-#ifdef __ARCH_SI_TRAPNO
3268		- to->si_trapno = from.si_trapno;
3269		-#endif
3270		- to->si_pkey = from.si_pkey;
3271		- break;
3272		- case SIL_CHLD:
3273		- to->si_pid = from.si_pid;
3274		- to->si_uid = from.si_uid;
3275		- to->si_status = from.si_status;
3276		-#ifdef CONFIG_X86_X32_ABI
3277		- if (in_x32_syscall()) {
3278		- to->si_utime = from._sifields._sigchld_x32._utime;
3279		- to->si_stime = from._sifields._sigchld_x32._stime;
3280		- } else
3281		-#endif
3282		- {
3283		- to->si_utime = from.si_utime;
3284		- to->si_stime = from.si_stime;
3285		- }
3286		- break;
3287		- case SIL_RT:
3288		- to->si_pid = from.si_pid;
3289		- to->si_uid = from.si_uid;
3290		- to->si_int = from.si_int;
3291		- break;
3292		- case SIL_SYS:
3293		- to->si_call_addr = compat_ptr(from.si_call_addr);
3294		- to->si_syscall = from.si_syscall;
3295		- to->si_arch = from.si_arch;
3296		- break;
3297		- }
3298		- return 0;
	3556	+ return post_copy_siginfo_from_user32(to, &from);
3299	3557	}
3300	3558	#endif /* CONFIG_COMPAT */
3301	3559
..	..	@@ -3305,8 +3563,8 @@
3305	3563	* @info: if non-null, the signal's siginfo is returned here
3306	3564	* @ts: upper bound on process time suspension
3307	3565	*/
3308		-static int do_sigtimedwait(const sigset_t which, siginfo_t info,
3309		- const struct timespec *ts)
	3566	+static int do_sigtimedwait(const sigset_t which, kernel_siginfo_t info,
	3567	+ const struct timespec64 *ts)
3310	3568	{
3311	3569	ktime_t *to = NULL, timeout = KTIME_MAX;
3312	3570	struct task_struct *tsk = current;
..	..	@@ -3314,9 +3572,9 @@
3314	3572	int sig, ret = 0;
3315	3573
3316	3574	if (ts) {
3317		- if (!timespec_valid(ts))
	3575	+ if (!timespec64_valid(ts))
3318	3576	return -EINVAL;
3319		- timeout = timespec_to_ktime(*ts);
	3577	+ timeout = timespec64_to_ktime(*ts);
3320	3578	to = &timeout;
3321	3579	}
3322	3580
..	..	@@ -3364,12 +3622,13 @@
3364	3622	* @sigsetsize: size of sigset_t type
3365	3623	*/
3366	3624	SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3367		- siginfo_t __user , uinfo, const struct timespec __user , uts,
	3625	+ siginfo_t __user *, uinfo,
	3626	+ const struct __kernel_timespec __user *, uts,
3368	3627	size_t, sigsetsize)
3369	3628	{
3370	3629	sigset_t these;
3371		- struct timespec ts;
3372		- siginfo_t info;
	3630	+ struct timespec64 ts;
	3631	+ kernel_siginfo_t info;
3373	3632	int ret;
3374	3633
3375	3634	/* XXX: Don't preclude handling different sized sigset_t's. */
..	..	@@ -3380,7 +3639,7 @@
3380	3639	return -EFAULT;
3381	3640
3382	3641	if (uts) {
3383		- if (copy_from_user(&ts, uts, sizeof(ts)))
	3642	+ if (get_timespec64(&ts, uts))
3384	3643	return -EFAULT;
3385	3644	}
3386	3645
..	..	@@ -3394,14 +3653,47 @@
3394	3653	return ret;
3395	3654	}
3396	3655
	3656	+#ifdef CONFIG_COMPAT_32BIT_TIME
	3657	+SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
	3658	+ siginfo_t __user *, uinfo,
	3659	+ const struct old_timespec32 __user *, uts,
	3660	+ size_t, sigsetsize)
	3661	+{
	3662	+ sigset_t these;
	3663	+ struct timespec64 ts;
	3664	+ kernel_siginfo_t info;
	3665	+ int ret;
	3666	+
	3667	+ if (sigsetsize != sizeof(sigset_t))
	3668	+ return -EINVAL;
	3669	+
	3670	+ if (copy_from_user(&these, uthese, sizeof(these)))
	3671	+ return -EFAULT;
	3672	+
	3673	+ if (uts) {
	3674	+ if (get_old_timespec32(&ts, uts))
	3675	+ return -EFAULT;
	3676	+ }
	3677	+
	3678	+ ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
	3679	+
	3680	+ if (ret > 0 && uinfo) {
	3681	+ if (copy_siginfo_to_user(uinfo, &info))
	3682	+ ret = -EFAULT;
	3683	+ }
	3684	+
	3685	+ return ret;
	3686	+}
	3687	+#endif
	3688	+
3397	3689	#ifdef CONFIG_COMPAT
3398		-COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
	3690	+COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
3399	3691	struct compat_siginfo __user *, uinfo,
3400		- struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
	3692	+ struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
3401	3693	{
3402	3694	sigset_t s;
3403		- struct timespec t;
3404		- siginfo_t info;
	3695	+ struct timespec64 t;
	3696	+ kernel_siginfo_t info;
3405	3697	long ret;
3406	3698
3407	3699	if (sigsetsize != sizeof(sigset_t))
..	..	@@ -3411,7 +3703,38 @@
3411	3703	return -EFAULT;
3412	3704
3413	3705	if (uts) {
3414		- if (compat_get_timespec(&t, uts))
	3706	+ if (get_timespec64(&t, uts))
	3707	+ return -EFAULT;
	3708	+ }
	3709	+
	3710	+ ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
	3711	+
	3712	+ if (ret > 0 && uinfo) {
	3713	+ if (copy_siginfo_to_user32(uinfo, &info))
	3714	+ ret = -EFAULT;
	3715	+ }
	3716	+
	3717	+ return ret;
	3718	+}
	3719	+
	3720	+#ifdef CONFIG_COMPAT_32BIT_TIME
	3721	+COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
	3722	+ struct compat_siginfo __user *, uinfo,
	3723	+ struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
	3724	+{
	3725	+ sigset_t s;
	3726	+ struct timespec64 t;
	3727	+ kernel_siginfo_t info;
	3728	+ long ret;
	3729	+
	3730	+ if (sigsetsize != sizeof(sigset_t))
	3731	+ return -EINVAL;
	3732	+
	3733	+ if (get_compat_sigset(&s, uthese))
	3734	+ return -EFAULT;
	3735	+
	3736	+ if (uts) {
	3737	+ if (get_old_timespec32(&t, uts))
3415	3738	return -EFAULT;
3416	3739	}
3417	3740
..	..	@@ -3425,8 +3748,9 @@
3425	3748	return ret;
3426	3749	}
3427	3750	#endif
	3751	+#endif
3428	3752
3429		-static inline void prepare_kill_siginfo(int sig, struct siginfo *info)
	3753	+static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
3430	3754	{
3431	3755	clear_siginfo(info);
3432	3756	info->si_signo = sig;
..	..	@@ -3443,7 +3767,7 @@
3443	3767	*/
3444	3768	SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3445	3769	{
3446		- struct siginfo info;
	3770	+ struct kernel_siginfo info;
3447	3771
3448	3772	prepare_kill_siginfo(sig, &info);
3449	3773
..	..	@@ -3471,7 +3795,7 @@
3471	3795	return true;
3472	3796	}
3473	3797
3474		-static int copy_siginfo_from_user_any(siginfo_t kinfo, siginfo_t __user info)
	3798	+static int copy_siginfo_from_user_any(kernel_siginfo_t kinfo, siginfo_t info)
3475	3799	{
3476	3800	#ifdef CONFIG_COMPAT
3477	3801	/*
..	..	@@ -3483,13 +3807,16 @@
3483	3807	return copy_siginfo_from_user32(
3484	3808	kinfo, (struct compat_siginfo __user *)info);
3485	3809	#endif
3486		- return copy_from_user(kinfo, info, sizeof(siginfo_t));
	3810	+ return copy_siginfo_from_user(kinfo, info);
3487	3811	}
3488	3812
3489	3813	static struct pid pidfd_to_pid(const struct file file)
3490	3814	{
3491		- if (file->f_op == &pidfd_fops)
3492		- return file->private_data;
	3815	+ struct pid *pid;
	3816	+
	3817	+ pid = pidfd_pid(file);
	3818	+ if (!IS_ERR(pid))
	3819	+ return pid;
3493	3820
3494	3821	return tgid_pidfd_to_pid(file);
3495	3822	}
..	..	@@ -3518,7 +3845,7 @@
3518	3845	int ret;
3519	3846	struct fd f;
3520	3847	struct pid *pid;
3521		- siginfo_t kinfo;
	3848	+ kernel_siginfo_t kinfo;
3522	3849
3523	3850	/* Enforce flags be set to 0 until we add an extension. */
3524	3851	if (flags)
..	..	@@ -3565,7 +3892,7 @@
3565	3892	}
3566	3893
3567	3894	static int
3568		-do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
	3895	+do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info)
3569	3896	{
3570	3897	struct task_struct *p;
3571	3898	int error = -ESRCH;
..	..	@@ -3596,7 +3923,7 @@
3596	3923
3597	3924	static int do_tkill(pid_t tgid, pid_t pid, int sig)
3598	3925	{
3599		- struct siginfo info;
	3926	+ struct kernel_siginfo info;
3600	3927
3601	3928	clear_siginfo(&info);
3602	3929	info.si_signo = sig;
..	..	@@ -3643,7 +3970,7 @@
3643	3970	return do_tkill(0, pid, sig);
3644	3971	}
3645	3972
3646		-static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
	3973	+static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info)
3647	3974	{
3648	3975	/* Not even root can pretend to send signals from the kernel.
3649	3976	* Nor can they impersonate a kill()/tgkill(), which adds source info.
..	..	@@ -3651,8 +3978,6 @@
3651	3978	if ((info->si_code >= 0 \|\| info->si_code == SI_TKILL) &&
3652	3979	(task_pid_vnr(current) != pid))
3653	3980	return -EPERM;
3654		-
3655		- info->si_signo = sig;
3656	3981
3657	3982	/* POSIX.1b doesn't mention process groups. */
3658	3983	return kill_proc_info(sig, info, pid);
..	..	@@ -3667,9 +3992,10 @@
3667	3992	SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3668	3993	siginfo_t __user *, uinfo)
3669	3994	{
3670		- siginfo_t info;
3671		- if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3672		- return -EFAULT;
	3995	+ kernel_siginfo_t info;
	3996	+ int ret = __copy_siginfo_from_user(sig, &info, uinfo);
	3997	+ if (unlikely(ret))
	3998	+ return ret;
3673	3999	return do_rt_sigqueueinfo(pid, sig, &info);
3674	4000	}
3675	4001
..	..	@@ -3679,15 +4005,15 @@
3679	4005	int, sig,
3680	4006	struct compat_siginfo __user *, uinfo)
3681	4007	{
3682		- siginfo_t info;
3683		- int ret = copy_siginfo_from_user32(&info, uinfo);
	4008	+ kernel_siginfo_t info;
	4009	+ int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
3684	4010	if (unlikely(ret))
3685	4011	return ret;
3686	4012	return do_rt_sigqueueinfo(pid, sig, &info);
3687	4013	}
3688	4014	#endif
3689	4015
3690		-static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
	4016	+static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info)
3691	4017	{
3692	4018	/* This is only valid for single tasks */
3693	4019	if (pid <= 0 \|\| tgid <= 0)
..	..	@@ -3700,19 +4026,16 @@
3700	4026	(task_pid_vnr(current) != pid))
3701	4027	return -EPERM;
3702	4028
3703		- info->si_signo = sig;
3704		-
3705	4029	return do_send_specific(tgid, pid, sig, info);
3706	4030	}
3707	4031
3708	4032	SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3709	4033	siginfo_t __user *, uinfo)
3710	4034	{
3711		- siginfo_t info;
3712		-
3713		- if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3714		- return -EFAULT;
3715		-
	4035	+ kernel_siginfo_t info;
	4036	+ int ret = __copy_siginfo_from_user(sig, &info, uinfo);
	4037	+ if (unlikely(ret))
	4038	+ return ret;
3716	4039	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3717	4040	}
3718	4041
..	..	@@ -3723,10 +4046,10 @@
3723	4046	int, sig,
3724	4047	struct compat_siginfo __user *, uinfo)
3725	4048	{
3726		- siginfo_t info;
3727		-
3728		- if (copy_siginfo_from_user32(&info, uinfo))
3729		- return -EFAULT;
	4049	+ kernel_siginfo_t info;
	4050	+ int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
	4051	+ if (unlikely(ret))
	4052	+ return ret;
3730	4053	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3731	4054	}
3732	4055	#endif
..	..	@@ -3771,6 +4094,22 @@
3771	4094	spin_lock_irq(&p->sighand->siglock);
3772	4095	if (oact)
3773	4096	oact = k;
	4097	+
	4098	+ /*
	4099	+ * Make sure that we never accidentally claim to support SA_UNSUPPORTED,
	4100	+ * e.g. by having an architecture use the bit in their uapi.
	4101	+ */
	4102	+ BUILD_BUG_ON(UAPI_SA_FLAGS & SA_UNSUPPORTED);
	4103	+
	4104	+ /*
	4105	+ * Clear unknown flag bits in order to allow userspace to detect missing
	4106	+ * support for flag bits and to allow the kernel to use non-uapi bits
	4107	+ * internally.
	4108	+ */
	4109	+ if (act)
	4110	+ act->sa.sa_flags &= UAPI_SA_FLAGS;
	4111	+ if (oact)
	4112	+ oact->sa.sa_flags &= UAPI_SA_FLAGS;
3774	4113
3775	4114	sigaction_compat_abi(act, oact);
3776	4115
..	..	@@ -4117,7 +4456,7 @@
4117	4456
4118	4457	if (act) {
4119	4458	old_sigset_t mask;
4120		- if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	4459	+ if (!access_ok(act, sizeof(*act)) \|\|
4121	4460	__get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\|
4122	4461	__get_user(new_ka.sa.sa_restorer, &act->sa_restorer) \|\|
4123	4462	__get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\|
..	..	@@ -4132,7 +4471,7 @@
4132	4471	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4133	4472
4134	4473	if (!ret && oact) {
4135		- if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	4474	+ if (!access_ok(oact, sizeof(*oact)) \|\|
4136	4475	__put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\|
4137	4476	__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) \|\|
4138	4477	__put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\|
..	..	@@ -4154,7 +4493,7 @@
4154	4493	compat_uptr_t handler, restorer;
4155	4494
4156	4495	if (act) {
4157		- if (!access_ok(VERIFY_READ, act, sizeof(*act)) \|\|
	4496	+ if (!access_ok(act, sizeof(*act)) \|\|
4158	4497	__get_user(handler, &act->sa_handler) \|\|
4159	4498	__get_user(restorer, &act->sa_restorer) \|\|
4160	4499	__get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\|
..	..	@@ -4172,7 +4511,7 @@
4172	4511	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4173	4512
4174	4513	if (!ret && oact) {
4175		- if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) \|\|
	4514	+ if (!access_ok(oact, sizeof(*oact)) \|\|
4176	4515	__put_user(ptr_to_compat(old_ka.sa.sa_handler),
4177	4516	&oact->sa_handler) \|\|
4178	4517	__put_user(ptr_to_compat(old_ka.sa.sa_restorer),
..	..	@@ -4309,12 +4648,78 @@
4309	4648	return NULL;
4310	4649	}
4311	4650
	4651	+static inline void siginfo_buildtime_checks(void)
	4652	+{
	4653	+ BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
	4654	+
	4655	+ /* Verify the offsets in the two siginfos match */
	4656	+#define CHECK_OFFSET(field) \
	4657	+ BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field))
	4658	+
	4659	+ /* kill */
	4660	+ CHECK_OFFSET(si_pid);
	4661	+ CHECK_OFFSET(si_uid);
	4662	+
	4663	+ /* timer */
	4664	+ CHECK_OFFSET(si_tid);
	4665	+ CHECK_OFFSET(si_overrun);
	4666	+ CHECK_OFFSET(si_value);
	4667	+
	4668	+ /* rt */
	4669	+ CHECK_OFFSET(si_pid);
	4670	+ CHECK_OFFSET(si_uid);
	4671	+ CHECK_OFFSET(si_value);
	4672	+
	4673	+ /* sigchld */
	4674	+ CHECK_OFFSET(si_pid);
	4675	+ CHECK_OFFSET(si_uid);
	4676	+ CHECK_OFFSET(si_status);
	4677	+ CHECK_OFFSET(si_utime);
	4678	+ CHECK_OFFSET(si_stime);
	4679	+
	4680	+ /* sigfault */
	4681	+ CHECK_OFFSET(si_addr);
	4682	+ CHECK_OFFSET(si_addr_lsb);
	4683	+ CHECK_OFFSET(si_lower);
	4684	+ CHECK_OFFSET(si_upper);
	4685	+ CHECK_OFFSET(si_pkey);
	4686	+
	4687	+ /* sigpoll */
	4688	+ CHECK_OFFSET(si_band);
	4689	+ CHECK_OFFSET(si_fd);
	4690	+
	4691	+ /* sigsys */
	4692	+ CHECK_OFFSET(si_call_addr);
	4693	+ CHECK_OFFSET(si_syscall);
	4694	+ CHECK_OFFSET(si_arch);
	4695	+#undef CHECK_OFFSET
	4696	+
	4697	+ /* usb asyncio */
	4698	+ BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
	4699	+ offsetof(struct siginfo, si_addr));
	4700	+ if (sizeof(int) == sizeof(void __user *)) {
	4701	+ BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
	4702	+ sizeof(void __user *));
	4703	+ } else {
	4704	+ BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
	4705	+ sizeof_field(struct siginfo, si_uid)) !=
	4706	+ sizeof(void __user *));
	4707	+ BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
	4708	+ offsetof(struct siginfo, si_uid));
	4709	+ }
	4710	+#ifdef CONFIG_COMPAT
	4711	+ BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
	4712	+ offsetof(struct compat_siginfo, si_addr));
	4713	+ BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
	4714	+ sizeof(compat_uptr_t));
	4715	+ BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
	4716	+ sizeof_field(struct siginfo, si_pid));
	4717	+#endif
	4718	+}
	4719	+
4312	4720	void __init signals_init(void)
4313	4721	{
4314		- /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
4315		- BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
4316		- != offsetof(struct siginfo, _sifields._pad));
4317		- BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
	4722	+ siginfo_buildtime_checks();
4318	4723
4319	4724	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
4320	4725	}