forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d 
 kernel/kernel/time/posix-timers.c
....@@ -1,34 +1,13 @@
1
+// SPDX-License-Identifier: GPL-2.0+
12 /*
2
- * linux/kernel/posix-timers.c
3
- *
4
- *
53  * 2002-10-15  Posix Clocks & timers
64  *                           by George Anzinger george@mvista.com
7
- *
85  *			     Copyright (C) 2002 2003 by MontaVista Software.
96  *
107  * 2004-06-01  Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
118  *			     Copyright (C) 2004 Boris Hu
129  *
13
- * This program is free software; you can redistribute it and/or modify
14
- * it under the terms of the GNU General Public License as published by
15
- * the Free Software Foundation; either version 2 of the License, or (at
16
- * your option) any later version.
17
- *
18
- * This program is distributed in the hope that it will be useful, but
19
- * WITHOUT ANY WARRANTY; without even the implied warranty of
20
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21
- * General Public License for more details.
22
-
23
- * You should have received a copy of the GNU General Public License
24
- * along with this program; if not, write to the Free Software
25
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
- *
27
- * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
28
- */
29
-
30
-/* These are all the functions necessary to implement
31
- * POSIX clocks & timers
10
+ * These are all the functions necessary to implement POSIX clocks & timers
3211  */
3312 #include <linux/mm.h>
3413 #include <linux/interrupt.h>
....@@ -51,6 +30,7 @@
5130 #include <linux/hashtable.h>
5231 #include <linux/compat.h>
5332 #include <linux/nospec.h>
33
+#include <linux/time_namespace.h>
5434 
5535 #include "timekeeping.h"
5636 #include "posix-timers.h"
....@@ -141,7 +121,8 @@
141121 {
142122 	struct k_itimer *timer;
143123 
144
-	hlist_for_each_entry_rcu(timer, head, t_hash) {
124
+	hlist_for_each_entry_rcu(timer, head, t_hash,
125
+				 lockdep_is_held(&hash_lock)) {
145126 		if ((timer->it_signal == sig) && (timer->it_id == id))
146127 			return timer;
147128 	}
....@@ -186,10 +167,15 @@
186167 }
187168 
188169 /* Get clock_realtime */
189
-static int posix_clock_realtime_get(clockid_t which_clock, struct timespec64 *tp)
170
+static int posix_get_realtime_timespec(clockid_t which_clock, struct timespec64 *tp)
190171 {
191172 	ktime_get_real_ts64(tp);
192173 	return 0;
174
+}
175
+
176
+static ktime_t posix_get_realtime_ktime(clockid_t which_clock)
177
+{
178
+	return ktime_get_real();
193179 }
194180 
195181 /* Set clock_realtime */
....@@ -200,7 +186,7 @@
200186 }
201187 
202188 static int posix_clock_realtime_adj(const clockid_t which_clock,
203
-				    struct timex *t)
189
+				    struct __kernel_timex *t)
204190 {
205191 	return do_adjtimex(t);
206192 }
....@@ -208,10 +194,16 @@
208194 /*
209195  * Get monotonic time for posix timers
210196  */
211
-static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp)
197
+static int posix_get_monotonic_timespec(clockid_t which_clock, struct timespec64 *tp)
212198 {
213199 	ktime_get_ts64(tp);
200
+	timens_add_monotonic(tp);
214201 	return 0;
202
+}
203
+
204
+static ktime_t posix_get_monotonic_ktime(clockid_t which_clock)
205
+{
206
+	return ktime_get();
215207 }
216208 
217209 /*
....@@ -220,6 +212,7 @@
220212 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp)
221213 {
222214 	ktime_get_raw_ts64(tp);
215
+	timens_add_monotonic(tp);
223216 	return 0;
224217 }
225218 
....@@ -234,6 +227,7 @@
234227 						struct timespec64 *tp)
235228 {
236229 	ktime_get_coarse_ts64(tp);
230
+	timens_add_monotonic(tp);
237231 	return 0;
238232 }
239233 
....@@ -243,16 +237,27 @@
243237 	return 0;
244238 }
245239 
246
-static int posix_get_boottime(const clockid_t which_clock, struct timespec64 *tp)
240
+static int posix_get_boottime_timespec(const clockid_t which_clock, struct timespec64 *tp)
247241 {
248242 	ktime_get_boottime_ts64(tp);
243
+	timens_add_boottime(tp);
249244 	return 0;
250245 }
251246 
252
-static int posix_get_tai(clockid_t which_clock, struct timespec64 *tp)
247
+static ktime_t posix_get_boottime_ktime(const clockid_t which_clock)
248
+{
249
+	return ktime_get_boottime();
250
+}
251
+
252
+static int posix_get_tai_timespec(clockid_t which_clock, struct timespec64 *tp)
253253 {
254254 	ktime_get_clocktai_ts64(tp);
255255 	return 0;
256
+}
257
+
258
+static ktime_t posix_get_tai_ktime(clockid_t which_clock)
259
+{
260
+	return ktime_get_clocktai();
256261 }
257262 
258263 static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
....@@ -305,7 +310,7 @@
305310  * To protect against the timer going away while the interrupt is queued,
306311  * we require that the it_requeue_pending flag be set.
307312  */
308
-void posixtimer_rearm(struct siginfo *info)
313
+void posixtimer_rearm(struct kernel_siginfo *info)
309314 {
310315 	struct k_itimer *timr;
311316 	unsigned long flags;
....@@ -434,12 +439,12 @@
434439 		rtn = pid_task(pid, PIDTYPE_PID);
435440 		if (!rtn || !same_thread_group(rtn, current))
436441 			return NULL;
437
-		/* FALLTHRU */
442
+		fallthrough;
438443 	case SIGEV_SIGNAL:
439444 	case SIGEV_THREAD:
440445 		if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX)
441446 			return NULL;
442
-		/* FALLTHRU */
447
+		fallthrough;
443448 	case SIGEV_NONE:
444449 		return pid;
445450 	default:
....@@ -666,7 +671,6 @@
666671 {
667672 	const struct k_clock *kc = timr->kclock;
668673 	ktime_t now, remaining, iv;
669
-	struct timespec64 ts64;
670674 	bool sig_none;
671675 
672676 	sig_none = timr->it_sigev_notify == SIGEV_NONE;
....@@ -684,12 +688,7 @@
684688 			return;
685689 	}
686690 
687
-	/*
688
-	 * The timespec64 based conversion is suboptimal, but it's not
689
-	 * worth to implement yet another callback.
690
-	 */
691
-	kc->clock_get(timr->it_clock, &ts64);
692
-	now = timespec64_to_ktime(ts64);
691
+	now = kc->clock_get_ktime(timr->it_clock);
693692 
694693 	/*
695694 	 * When a requeue is pending or this is a SIGEV_NONE timer move the
....@@ -751,14 +750,14 @@
751750 
752751 #ifdef CONFIG_COMPAT_32BIT_TIME
753752 
754
-COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
755
-		       struct compat_itimerspec __user *, setting)
753
+SYSCALL_DEFINE2(timer_gettime32, timer_t, timer_id,
754
+		struct old_itimerspec32 __user *, setting)
756755 {
757756 	struct itimerspec64 cur_setting;
758757 
759758 	int ret = do_timer_gettime(timer_id, &cur_setting);
760759 	if (!ret) {
761
-		if (put_compat_itimerspec64(&cur_setting, setting))
760
+		if (put_old_itimerspec32(&cur_setting, setting))
762761 			ret = -EFAULT;
763762 	}
764763 	return ret;
....@@ -802,7 +801,7 @@
802801 	 * Posix magic: Relative CLOCK_REALTIME timers are not affected by
803802 	 * clock modifications, so they become CLOCK_MONOTONIC based under the
804803 	 * hood. See hrtimer_init(). Update timr->kclock, so the generic
805
-	 * functions which use timr->kclock->clock_get() work.
804
+	 * functions which use timr->kclock->clock_get_*() work.
806805 	 *
807806 	 * Note: it_clock stays unmodified, because the next timer_set() might
808807 	 * use ABSTIME, so it needs to switch back.
....@@ -826,15 +825,33 @@
826825 	return hrtimer_try_to_cancel(&timr->it.real.timer);
827826 }
828827 
829
-static void timer_wait_for_callback(const struct k_clock *kc, struct k_itimer *timer)
828
+static void common_timer_wait_running(struct k_itimer *timer)
830829 {
831
-	if (kc->timer_arm == common_hrtimer_arm)
832
-		hrtimer_grab_expiry_lock(&timer->it.real.timer);
833
-	else if (kc == &alarm_clock)
834
-		hrtimer_grab_expiry_lock(&timer->it.alarm.alarmtimer.timer);
835
-	else
836
-		/* posix-cpu-timers */
837
-		cpu_timers_grab_expiry_lock(timer);
830
+	hrtimer_cancel_wait_running(&timer->it.real.timer);
831
+}
832
+
833
+/*
834
+ * On PREEMPT_RT this prevent priority inversion against softirq kthread in
835
+ * case it gets preempted while executing a timer callback. See comments in
836
+ * hrtimer_cancel_wait_running. For PREEMPT_RT=n this just results in a
837
+ * cpu_relax().
838
+ */
839
+static struct k_itimer *timer_wait_running(struct k_itimer *timer,
840
+					   unsigned long *flags)
841
+{
842
+	const struct k_clock *kc = READ_ONCE(timer->kclock);
843
+	timer_t timer_id = READ_ONCE(timer->it_id);
844
+
845
+	/* Prevent kfree(timer) after dropping the lock */
846
+	rcu_read_lock();
847
+	unlock_timer(timer, *flags);
848
+
849
+	if (!WARN_ON_ONCE(!kc->timer_wait_running))
850
+		kc->timer_wait_running(timer);
851
+
852
+	rcu_read_unlock();
853
+	/* Relock the timer. It might be not longer hashed. */
854
+	return lock_timer(timer_id, flags);
838855 }
839856 
840857 /* Set a POSIX.1b interval timer. */
....@@ -869,6 +886,8 @@
869886 
870887 	timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
871888 	expires = timespec64_to_ktime(new_setting->it_value);
889
+	if (flags & TIMER_ABSTIME)
890
+		expires = timens_ktime_to_host(timr->it_clock, expires);
872891 	sigev_none = timr->it_sigev_notify == SIGEV_NONE;
873892 
874893 	kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
....@@ -876,13 +895,13 @@
876895 	return 0;
877896 }
878897 
879
-static int do_timer_settime(timer_t timer_id, int flags,
898
+static int do_timer_settime(timer_t timer_id, int tmr_flags,
880899 			    struct itimerspec64 *new_spec64,
881900 			    struct itimerspec64 *old_spec64)
882901 {
883902 	const struct k_clock *kc;
884903 	struct k_itimer *timr;
885
-	unsigned long flag;
904
+	unsigned long flags;
886905 	int error = 0;
887906 
888907 	if (!timespec64_valid(&new_spec64->it_interval) ||
....@@ -891,8 +910,9 @@
891910 
892911 	if (old_spec64)
893912 		memset(old_spec64, 0, sizeof(*old_spec64));
913
+
914
+	timr = lock_timer(timer_id, &flags);
894915 retry:
895
-	timr = lock_timer(timer_id, &flag);
896916 	if (!timr)
897917 		return -EINVAL;
898918 
....@@ -900,17 +920,16 @@
900920 	if (WARN_ON_ONCE(!kc || !kc->timer_set))
901921 		error = -EINVAL;
902922 	else
903
-		error = kc->timer_set(timr, flags, new_spec64, old_spec64);
923
+		error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64);
904924 
905925 	if (error == TIMER_RETRY) {
906
-		rcu_read_lock();
907
-		unlock_timer(timr, flag);
908
-		timer_wait_for_callback(kc, timr);
909
-		rcu_read_unlock();
910
-		old_spec64 = NULL;	// We already got the old time...
926
+		// We already got the old time...
927
+		old_spec64 = NULL;
928
+		/* Unlocks and relocks the timer if it still exists */
929
+		timr = timer_wait_running(timr, &flags);
911930 		goto retry;
912931 	}
913
-	unlock_timer(timr, flag);
932
+	unlock_timer(timr, flags);
914933 
915934 	return error;
916935 }
....@@ -939,9 +958,9 @@
939958 }
940959 
941960 #ifdef CONFIG_COMPAT_32BIT_TIME
942
-COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
943
-		       struct compat_itimerspec __user *, new,
944
-		       struct compat_itimerspec __user *, old)
961
+SYSCALL_DEFINE4(timer_settime32, timer_t, timer_id, int, flags,
962
+		struct old_itimerspec32 __user *, new,
963
+		struct old_itimerspec32 __user *, old)
945964 {
946965 	struct itimerspec64 new_spec, old_spec;
947966 	struct itimerspec64 *rtn = old ? &old_spec : NULL;
....@@ -949,12 +968,12 @@
949968 
950969 	if (!new)
951970 		return -EINVAL;
952
-	if (get_compat_itimerspec64(&new_spec, new))
971
+	if (get_old_itimerspec32(&new_spec, new))
953972 		return -EFAULT;
954973 
955974 	error = do_timer_settime(timer_id, flags, &new_spec, rtn);
956975 	if (!error && old) {
957
-		if (put_compat_itimerspec64(&old_spec, old))
976
+		if (put_old_itimerspec32(&old_spec, old))
958977 			error = -EFAULT;
959978 	}
960979 	return error;
....@@ -972,21 +991,13 @@
972991 	return 0;
973992 }
974993 
975
-static int timer_delete_hook(struct k_itimer *timer)
994
+static inline int timer_delete_hook(struct k_itimer *timer)
976995 {
977996 	const struct k_clock *kc = timer->kclock;
978
-	int ret;
979997 
980998 	if (WARN_ON_ONCE(!kc || !kc->timer_del))
981999 		return -EINVAL;
982
-	ret = kc->timer_del(timer);
983
-	if (ret == TIMER_RETRY) {
984
-		rcu_read_lock();
985
-		spin_unlock_irq(&timer->it_lock);
986
-		timer_wait_for_callback(kc, timer);
987
-		rcu_read_unlock();
988
-	}
989
-	return ret;
1000
+	return kc->timer_del(timer);
9901001 }
9911002 
9921003 /* Delete a POSIX.1b interval timer. */
....@@ -995,13 +1006,17 @@
9951006 	struct k_itimer *timer;
9961007 	unsigned long flags;
9971008 
998
-retry_delete:
9991009 	timer = lock_timer(timer_id, &flags);
1010
+
1011
+retry_delete:
10001012 	if (!timer)
10011013 		return -EINVAL;
10021014 
1003
-	if (timer_delete_hook(timer) == TIMER_RETRY)
1015
+	if (unlikely(timer_delete_hook(timer) == TIMER_RETRY)) {
1016
+		/* Unlocks and relocks the timer if it still exists */
1017
+		timer = timer_wait_running(timer, &flags);
10041018 		goto retry_delete;
1019
+	}
10051020 
10061021 	spin_lock(&current->sighand->siglock);
10071022 	list_del(&timer->list);
....@@ -1022,35 +1037,38 @@
10221037  */
10231038 static void itimer_delete(struct k_itimer *timer)
10241039 {
1025
-	unsigned long flags;
1026
-
10271040 retry_delete:
1028
-	spin_lock_irqsave(&timer->it_lock, flags);
1041
+	spin_lock_irq(&timer->it_lock);
10291042 
1030
-	if (timer_delete_hook(timer) == TIMER_RETRY)
1043
+	if (timer_delete_hook(timer) == TIMER_RETRY) {
1044
+		spin_unlock_irq(&timer->it_lock);
10311045 		goto retry_delete;
1032
-
1046
+	}
10331047 	list_del(&timer->list);
1034
-	/*
1035
-	 * This keeps any tasks waiting on the spin lock from thinking
1036
-	 * they got something (see the lock code above).
1037
-	 */
1038
-	timer->it_signal = NULL;
10391048 
1040
-	unlock_timer(timer, flags);
1049
+	spin_unlock_irq(&timer->it_lock);
10411050 	release_posix_timer(timer, IT_ID_SET);
10421051 }
10431052 
10441053 /*
1045
- * This is called by do_exit or de_thread, only when there are no more
1046
- * references to the shared signal_struct.
1054
+ * This is called by do_exit or de_thread, only when nobody else can
1055
+ * modify the signal->posix_timers list. Yet we need sighand->siglock
1056
+ * to prevent the race with /proc/pid/timers.
10471057  */
1048
-void exit_itimers(struct signal_struct *sig)
1058
+void exit_itimers(struct task_struct *tsk)
10491059 {
1060
+	struct list_head timers;
10501061 	struct k_itimer *tmr;
10511062 
1052
-	while (!list_empty(&sig->posix_timers)) {
1053
-		tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
1063
+	if (list_empty(&tsk->signal->posix_timers))
1064
+		return;
1065
+
1066
+	spin_lock_irq(&tsk->sighand->siglock);
1067
+	list_replace_init(&tsk->signal->posix_timers, &timers);
1068
+	spin_unlock_irq(&tsk->sighand->siglock);
1069
+
1070
+	while (!list_empty(&timers)) {
1071
+		tmr = list_first_entry(&timers, struct k_itimer, list);
10541072 		itimer_delete(tmr);
10551073 	}
10561074 }
....@@ -1080,7 +1098,7 @@
10801098 	if (!kc)
10811099 		return -EINVAL;
10821100 
1083
-	error = kc->clock_get(which_clock, &kernel_tp);
1101
+	error = kc->clock_get_timespec(which_clock, &kernel_tp);
10841102 
10851103 	if (!error && put_timespec64(&kernel_tp, tp))
10861104 		error = -EFAULT;
....@@ -1088,22 +1106,28 @@
10881106 	return error;
10891107 }
10901108 
1091
-SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1092
-		struct timex __user *, utx)
1109
+int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx)
10931110 {
10941111 	const struct k_clock *kc = clockid_to_kclock(which_clock);
1095
-	struct timex ktx;
1096
-	int err;
10971112 
10981113 	if (!kc)
10991114 		return -EINVAL;
11001115 	if (!kc->clock_adj)
11011116 		return -EOPNOTSUPP;
11021117 
1118
+	return kc->clock_adj(which_clock, ktx);
1119
+}
1120
+
1121
+SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1122
+		struct __kernel_timex __user *, utx)
1123
+{
1124
+	struct __kernel_timex ktx;
1125
+	int err;
1126
+
11031127 	if (copy_from_user(&ktx, utx, sizeof(ktx)))
11041128 		return -EFAULT;
11051129 
1106
-	err = kc->clock_adj(which_clock, &ktx);
1130
+	err = do_clock_adjtime(which_clock, &ktx);
11071131 
11081132 	if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
11091133 		return -EFAULT;
....@@ -1131,8 +1155,8 @@
11311155 
11321156 #ifdef CONFIG_COMPAT_32BIT_TIME
11331157 
1134
-COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
1135
-		       struct compat_timespec __user *, tp)
1158
+SYSCALL_DEFINE2(clock_settime32, clockid_t, which_clock,
1159
+		struct old_timespec32 __user *, tp)
11361160 {
11371161 	const struct k_clock *kc = clockid_to_kclock(which_clock);
11381162 	struct timespec64 ts;
....@@ -1140,14 +1164,14 @@
11401164 	if (!kc || !kc->clock_set)
11411165 		return -EINVAL;
11421166 
1143
-	if (compat_get_timespec64(&ts, tp))
1167
+	if (get_old_timespec32(&ts, tp))
11441168 		return -EFAULT;
11451169 
11461170 	return kc->clock_set(which_clock, &ts);
11471171 }
11481172 
1149
-COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
1150
-		       struct compat_timespec __user *, tp)
1173
+SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
1174
+		struct old_timespec32 __user *, tp)
11511175 {
11521176 	const struct k_clock *kc = clockid_to_kclock(which_clock);
11531177 	struct timespec64 ts;
....@@ -1156,48 +1180,34 @@
11561180 	if (!kc)
11571181 		return -EINVAL;
11581182 
1159
-	err = kc->clock_get(which_clock, &ts);
1183
+	err = kc->clock_get_timespec(which_clock, &ts);
11601184 
1161
-	if (!err && compat_put_timespec64(&ts, tp))
1185
+	if (!err && put_old_timespec32(&ts, tp))
11621186 		err = -EFAULT;
11631187 
11641188 	return err;
11651189 }
11661190 
1167
-#endif
1168
-
1169
-#ifdef CONFIG_COMPAT
1170
-
1171
-COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
1172
-		       struct compat_timex __user *, utp)
1191
+SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock,
1192
+		struct old_timex32 __user *, utp)
11731193 {
1174
-	const struct k_clock *kc = clockid_to_kclock(which_clock);
1175
-	struct timex ktx;
1194
+	struct __kernel_timex ktx;
11761195 	int err;
11771196 
1178
-	if (!kc)
1179
-		return -EINVAL;
1180
-	if (!kc->clock_adj)
1181
-		return -EOPNOTSUPP;
1182
-
1183
-	err = compat_get_timex(&ktx, utp);
1197
+	err = get_old_timex32(&ktx, utp);
11841198 	if (err)
11851199 		return err;
11861200 
1187
-	err = kc->clock_adj(which_clock, &ktx);
1201
+	err = do_clock_adjtime(which_clock, &ktx);
11881202 
1189
-	if (err >= 0 && compat_put_timex(utp, &ktx))
1203
+	if (err >= 0 && put_old_timex32(utp, &ktx))
11901204 		return -EFAULT;
11911205 
11921206 	return err;
11931207 }
11941208 
1195
-#endif
1196
-
1197
-#ifdef CONFIG_COMPAT_32BIT_TIME
1198
-
1199
-COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
1200
-		       struct compat_timespec __user *, tp)
1209
+SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
1210
+		struct old_timespec32 __user *, tp)
12011211 {
12021212 	const struct k_clock *kc = clockid_to_kclock(which_clock);
12031213 	struct timespec64 ts;
....@@ -1207,7 +1217,7 @@
12071217 		return -EINVAL;
12081218 
12091219 	err = kc->clock_getres(which_clock, &ts);
1210
-	if (!err && tp && compat_put_timespec64(&ts, tp))
1220
+	if (!err && tp && put_old_timespec32(&ts, tp))
12111221 		return -EFAULT;
12121222 
12131223 	return err;
....@@ -1221,7 +1231,22 @@
12211231 static int common_nsleep(const clockid_t which_clock, int flags,
12221232 			 const struct timespec64 *rqtp)
12231233 {
1224
-	return hrtimer_nanosleep(rqtp, flags & TIMER_ABSTIME ?
1234
+	ktime_t texp = timespec64_to_ktime(*rqtp);
1235
+
1236
+	return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
1237
+				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
1238
+				 which_clock);
1239
+}
1240
+
1241
+static int common_nsleep_timens(const clockid_t which_clock, int flags,
1242
+			 const struct timespec64 *rqtp)
1243
+{
1244
+	ktime_t texp = timespec64_to_ktime(*rqtp);
1245
+
1246
+	if (flags & TIMER_ABSTIME)
1247
+		texp = timens_ktime_to_host(which_clock, texp);
1248
+
1249
+	return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ?
12251250 				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
12261251 				 which_clock);
12271252 }
....@@ -1253,9 +1278,9 @@
12531278 
12541279 #ifdef CONFIG_COMPAT_32BIT_TIME
12551280 
1256
-COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
1257
-		       struct compat_timespec __user *, rqtp,
1258
-		       struct compat_timespec __user *, rmtp)
1281
+SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags,
1282
+		struct old_timespec32 __user *, rqtp,
1283
+		struct old_timespec32 __user *, rmtp)
12591284 {
12601285 	const struct k_clock *kc = clockid_to_kclock(which_clock);
12611286 	struct timespec64 t;
....@@ -1265,7 +1290,7 @@
12651290 	if (!kc->nsleep)
12661291 		return -EOPNOTSUPP;
12671292 
1268
-	if (compat_get_timespec64(&t, rqtp))
1293
+	if (get_old_timespec32(&t, rqtp))
12691294 		return -EFAULT;
12701295 
12711296 	if (!timespec64_valid(&t))
....@@ -1282,7 +1307,8 @@
12821307 
12831308 static const struct k_clock clock_realtime = {
12841309 	.clock_getres		= posix_get_hrtimer_res,
1285
-	.clock_get		= posix_clock_realtime_get,
1310
+	.clock_get_timespec	= posix_get_realtime_timespec,
1311
+	.clock_get_ktime	= posix_get_realtime_ktime,
12861312 	.clock_set		= posix_clock_realtime_set,
12871313 	.clock_adj		= posix_clock_realtime_adj,
12881314 	.nsleep			= common_nsleep,
....@@ -1294,13 +1320,15 @@
12941320 	.timer_forward		= common_hrtimer_forward,
12951321 	.timer_remaining	= common_hrtimer_remaining,
12961322 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1323
+	.timer_wait_running	= common_timer_wait_running,
12971324 	.timer_arm		= common_hrtimer_arm,
12981325 };
12991326 
13001327 static const struct k_clock clock_monotonic = {
13011328 	.clock_getres		= posix_get_hrtimer_res,
1302
-	.clock_get		= posix_ktime_get_ts,
1303
-	.nsleep			= common_nsleep,
1329
+	.clock_get_timespec	= posix_get_monotonic_timespec,
1330
+	.clock_get_ktime	= posix_get_monotonic_ktime,
1331
+	.nsleep			= common_nsleep_timens,
13041332 	.timer_create		= common_timer_create,
13051333 	.timer_set		= common_timer_set,
13061334 	.timer_get		= common_timer_get,
....@@ -1309,27 +1337,29 @@
13091337 	.timer_forward		= common_hrtimer_forward,
13101338 	.timer_remaining	= common_hrtimer_remaining,
13111339 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1340
+	.timer_wait_running	= common_timer_wait_running,
13121341 	.timer_arm		= common_hrtimer_arm,
13131342 };
13141343 
13151344 static const struct k_clock clock_monotonic_raw = {
13161345 	.clock_getres		= posix_get_hrtimer_res,
1317
-	.clock_get		= posix_get_monotonic_raw,
1346
+	.clock_get_timespec	= posix_get_monotonic_raw,
13181347 };
13191348 
13201349 static const struct k_clock clock_realtime_coarse = {
13211350 	.clock_getres		= posix_get_coarse_res,
1322
-	.clock_get		= posix_get_realtime_coarse,
1351
+	.clock_get_timespec	= posix_get_realtime_coarse,
13231352 };
13241353 
13251354 static const struct k_clock clock_monotonic_coarse = {
13261355 	.clock_getres		= posix_get_coarse_res,
1327
-	.clock_get		= posix_get_monotonic_coarse,
1356
+	.clock_get_timespec	= posix_get_monotonic_coarse,
13281357 };
13291358 
13301359 static const struct k_clock clock_tai = {
13311360 	.clock_getres		= posix_get_hrtimer_res,
1332
-	.clock_get		= posix_get_tai,
1361
+	.clock_get_ktime	= posix_get_tai_ktime,
1362
+	.clock_get_timespec	= posix_get_tai_timespec,
13331363 	.nsleep			= common_nsleep,
13341364 	.timer_create		= common_timer_create,
13351365 	.timer_set		= common_timer_set,
....@@ -1339,13 +1369,15 @@
13391369 	.timer_forward		= common_hrtimer_forward,
13401370 	.timer_remaining	= common_hrtimer_remaining,
13411371 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1372
+	.timer_wait_running	= common_timer_wait_running,
13421373 	.timer_arm		= common_hrtimer_arm,
13431374 };
13441375 
13451376 static const struct k_clock clock_boottime = {
13461377 	.clock_getres		= posix_get_hrtimer_res,
1347
-	.clock_get		= posix_get_boottime,
1348
-	.nsleep			= common_nsleep,
1378
+	.clock_get_ktime	= posix_get_boottime_ktime,
1379
+	.clock_get_timespec	= posix_get_boottime_timespec,
1380
+	.nsleep			= common_nsleep_timens,
13491381 	.timer_create		= common_timer_create,
13501382 	.timer_set		= common_timer_set,
13511383 	.timer_get		= common_timer_get,
....@@ -1354,6 +1386,7 @@
13541386 	.timer_forward		= common_hrtimer_forward,
13551387 	.timer_remaining	= common_hrtimer_remaining,
13561388 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1389
+	.timer_wait_running	= common_timer_wait_running,
13571390 	.timer_arm		= common_hrtimer_arm,
13581391 };
13591392