forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f 
 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:
....@@ -463,7 +468,7 @@
463468 
464469 static void k_itimer_rcu_free(struct rcu_head *head)
465470 {
466
-	struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu);
471
+	struct k_itimer *tmr = container_of(head, struct k_itimer, rcu);
467472 
468473 	kmem_cache_free(posix_timers_cache, tmr);
469474 }
....@@ -480,7 +485,7 @@
480485 	}
481486 	put_pid(tmr->it_pid);
482487 	sigqueue_free(tmr->sigq);
483
-	call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
488
+	call_rcu(&tmr->rcu, k_itimer_rcu_free);
484489 }
485490 
486491 static int common_timer_create(struct k_itimer *new_timer)
....@@ -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.
....@@ -824,6 +823,35 @@
824823 static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
825824 {
826825 	return hrtimer_try_to_cancel(&timr->it.real.timer);
826
+}
827
+
828
+static void common_timer_wait_running(struct k_itimer *timer)
829
+{
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);
827855 }
828856 
829857 /* Set a POSIX.1b interval timer. */
....@@ -858,6 +886,8 @@
858886 
859887 	timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
860888 	expires = timespec64_to_ktime(new_setting->it_value);
889
+	if (flags & TIMER_ABSTIME)
890
+		expires = timens_ktime_to_host(timr->it_clock, expires);
861891 	sigev_none = timr->it_sigev_notify == SIGEV_NONE;
862892 
863893 	kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
....@@ -865,13 +895,13 @@
865895 	return 0;
866896 }
867897 
868
-static int do_timer_settime(timer_t timer_id, int flags,
898
+static int do_timer_settime(timer_t timer_id, int tmr_flags,
869899 			    struct itimerspec64 *new_spec64,
870900 			    struct itimerspec64 *old_spec64)
871901 {
872902 	const struct k_clock *kc;
873903 	struct k_itimer *timr;
874
-	unsigned long flag;
904
+	unsigned long flags;
875905 	int error = 0;
876906 
877907 	if (!timespec64_valid(&new_spec64->it_interval) ||
....@@ -880,8 +910,9 @@
880910 
881911 	if (old_spec64)
882912 		memset(old_spec64, 0, sizeof(*old_spec64));
913
+
914
+	timr = lock_timer(timer_id, &flags);
883915 retry:
884
-	timr = lock_timer(timer_id, &flag);
885916 	if (!timr)
886917 		return -EINVAL;
887918 
....@@ -889,13 +920,16 @@
889920 	if (WARN_ON_ONCE(!kc || !kc->timer_set))
890921 		error = -EINVAL;
891922 	else
892
-		error = kc->timer_set(timr, flags, new_spec64, old_spec64);
923
+		error = kc->timer_set(timr, tmr_flags, new_spec64, old_spec64);
893924 
894
-	unlock_timer(timr, flag);
895925 	if (error == TIMER_RETRY) {
896
-		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);
897930 		goto retry;
898931 	}
932
+	unlock_timer(timr, flags);
899933 
900934 	return error;
901935 }
....@@ -924,9 +958,9 @@
924958 }
925959 
926960 #ifdef CONFIG_COMPAT_32BIT_TIME
927
-COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
928
-		       struct compat_itimerspec __user *, new,
929
-		       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)
930964 {
931965 	struct itimerspec64 new_spec, old_spec;
932966 	struct itimerspec64 *rtn = old ? &old_spec : NULL;
....@@ -934,12 +968,12 @@
934968 
935969 	if (!new)
936970 		return -EINVAL;
937
-	if (get_compat_itimerspec64(&new_spec, new))
971
+	if (get_old_itimerspec32(&new_spec, new))
938972 		return -EFAULT;
939973 
940974 	error = do_timer_settime(timer_id, flags, &new_spec, rtn);
941975 	if (!error && old) {
942
-		if (put_compat_itimerspec64(&old_spec, old))
976
+		if (put_old_itimerspec32(&old_spec, old))
943977 			error = -EFAULT;
944978 	}
945979 	return error;
....@@ -972,13 +1006,15 @@
9721006 	struct k_itimer *timer;
9731007 	unsigned long flags;
9741008 
975
-retry_delete:
9761009 	timer = lock_timer(timer_id, &flags);
1010
+
1011
+retry_delete:
9771012 	if (!timer)
9781013 		return -EINVAL;
9791014 
980
-	if (timer_delete_hook(timer) == TIMER_RETRY) {
981
-		unlock_timer(timer, flags);
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);
9821018 		goto retry_delete;
9831019 	}
9841020 
....@@ -1001,36 +1037,38 @@
10011037  */
10021038 static void itimer_delete(struct k_itimer *timer)
10031039 {
1004
-	unsigned long flags;
1005
-
10061040 retry_delete:
1007
-	spin_lock_irqsave(&timer->it_lock, flags);
1041
+	spin_lock_irq(&timer->it_lock);
10081042 
10091043 	if (timer_delete_hook(timer) == TIMER_RETRY) {
1010
-		unlock_timer(timer, flags);
1044
+		spin_unlock_irq(&timer->it_lock);
10111045 		goto retry_delete;
10121046 	}
10131047 	list_del(&timer->list);
1014
-	/*
1015
-	 * This keeps any tasks waiting on the spin lock from thinking
1016
-	 * they got something (see the lock code above).
1017
-	 */
1018
-	timer->it_signal = NULL;
10191048 
1020
-	unlock_timer(timer, flags);
1049
+	spin_unlock_irq(&timer->it_lock);
10211050 	release_posix_timer(timer, IT_ID_SET);
10221051 }
10231052 
10241053 /*
1025
- * This is called by do_exit or de_thread, only when there are no more
1026
- * 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.
10271057  */
1028
-void exit_itimers(struct signal_struct *sig)
1058
+void exit_itimers(struct task_struct *tsk)
10291059 {
1060
+	struct list_head timers;
10301061 	struct k_itimer *tmr;
10311062 
1032
-	while (!list_empty(&sig->posix_timers)) {
1033
-		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);
10341072 		itimer_delete(tmr);
10351073 	}
10361074 }
....@@ -1060,7 +1098,7 @@
10601098 	if (!kc)
10611099 		return -EINVAL;
10621100 
1063
-	error = kc->clock_get(which_clock, &kernel_tp);
1101
+	error = kc->clock_get_timespec(which_clock, &kernel_tp);
10641102 
10651103 	if (!error && put_timespec64(&kernel_tp, tp))
10661104 		error = -EFAULT;
....@@ -1068,22 +1106,28 @@
10681106 	return error;
10691107 }
10701108 
1071
-SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
1072
-		struct timex __user *, utx)
1109
+int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx)
10731110 {
10741111 	const struct k_clock *kc = clockid_to_kclock(which_clock);
1075
-	struct timex ktx;
1076
-	int err;
10771112 
10781113 	if (!kc)
10791114 		return -EINVAL;
10801115 	if (!kc->clock_adj)
10811116 		return -EOPNOTSUPP;
10821117 
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
+
10831127 	if (copy_from_user(&ktx, utx, sizeof(ktx)))
10841128 		return -EFAULT;
10851129 
1086
-	err = kc->clock_adj(which_clock, &ktx);
1130
+	err = do_clock_adjtime(which_clock, &ktx);
10871131 
10881132 	if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
10891133 		return -EFAULT;
....@@ -1111,8 +1155,8 @@
11111155 
11121156 #ifdef CONFIG_COMPAT_32BIT_TIME
11131157 
1114
-COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
1115
-		       struct compat_timespec __user *, tp)
1158
+SYSCALL_DEFINE2(clock_settime32, clockid_t, which_clock,
1159
+		struct old_timespec32 __user *, tp)
11161160 {
11171161 	const struct k_clock *kc = clockid_to_kclock(which_clock);
11181162 	struct timespec64 ts;
....@@ -1120,14 +1164,14 @@
11201164 	if (!kc || !kc->clock_set)
11211165 		return -EINVAL;
11221166 
1123
-	if (compat_get_timespec64(&ts, tp))
1167
+	if (get_old_timespec32(&ts, tp))
11241168 		return -EFAULT;
11251169 
11261170 	return kc->clock_set(which_clock, &ts);
11271171 }
11281172 
1129
-COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
1130
-		       struct compat_timespec __user *, tp)
1173
+SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
1174
+		struct old_timespec32 __user *, tp)
11311175 {
11321176 	const struct k_clock *kc = clockid_to_kclock(which_clock);
11331177 	struct timespec64 ts;
....@@ -1136,48 +1180,34 @@
11361180 	if (!kc)
11371181 		return -EINVAL;
11381182 
1139
-	err = kc->clock_get(which_clock, &ts);
1183
+	err = kc->clock_get_timespec(which_clock, &ts);
11401184 
1141
-	if (!err && compat_put_timespec64(&ts, tp))
1185
+	if (!err && put_old_timespec32(&ts, tp))
11421186 		err = -EFAULT;
11431187 
11441188 	return err;
11451189 }
11461190 
1147
-#endif
1148
-
1149
-#ifdef CONFIG_COMPAT
1150
-
1151
-COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
1152
-		       struct compat_timex __user *, utp)
1191
+SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock,
1192
+		struct old_timex32 __user *, utp)
11531193 {
1154
-	const struct k_clock *kc = clockid_to_kclock(which_clock);
1155
-	struct timex ktx;
1194
+	struct __kernel_timex ktx;
11561195 	int err;
11571196 
1158
-	if (!kc)
1159
-		return -EINVAL;
1160
-	if (!kc->clock_adj)
1161
-		return -EOPNOTSUPP;
1162
-
1163
-	err = compat_get_timex(&ktx, utp);
1197
+	err = get_old_timex32(&ktx, utp);
11641198 	if (err)
11651199 		return err;
11661200 
1167
-	err = kc->clock_adj(which_clock, &ktx);
1201
+	err = do_clock_adjtime(which_clock, &ktx);
11681202 
1169
-	if (err >= 0 && compat_put_timex(utp, &ktx))
1203
+	if (err >= 0 && put_old_timex32(utp, &ktx))
11701204 		return -EFAULT;
11711205 
11721206 	return err;
11731207 }
11741208 
1175
-#endif
1176
-
1177
-#ifdef CONFIG_COMPAT_32BIT_TIME
1178
-
1179
-COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
1180
-		       struct compat_timespec __user *, tp)
1209
+SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
1210
+		struct old_timespec32 __user *, tp)
11811211 {
11821212 	const struct k_clock *kc = clockid_to_kclock(which_clock);
11831213 	struct timespec64 ts;
....@@ -1187,7 +1217,7 @@
11871217 		return -EINVAL;
11881218 
11891219 	err = kc->clock_getres(which_clock, &ts);
1190
-	if (!err && tp && compat_put_timespec64(&ts, tp))
1220
+	if (!err && tp && put_old_timespec32(&ts, tp))
11911221 		return -EFAULT;
11921222 
11931223 	return err;
....@@ -1201,7 +1231,22 @@
12011231 static int common_nsleep(const clockid_t which_clock, int flags,
12021232 			 const struct timespec64 *rqtp)
12031233 {
1204
-	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 ?
12051250 				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
12061251 				 which_clock);
12071252 }
....@@ -1233,9 +1278,9 @@
12331278 
12341279 #ifdef CONFIG_COMPAT_32BIT_TIME
12351280 
1236
-COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
1237
-		       struct compat_timespec __user *, rqtp,
1238
-		       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)
12391284 {
12401285 	const struct k_clock *kc = clockid_to_kclock(which_clock);
12411286 	struct timespec64 t;
....@@ -1245,7 +1290,7 @@
12451290 	if (!kc->nsleep)
12461291 		return -EOPNOTSUPP;
12471292 
1248
-	if (compat_get_timespec64(&t, rqtp))
1293
+	if (get_old_timespec32(&t, rqtp))
12491294 		return -EFAULT;
12501295 
12511296 	if (!timespec64_valid(&t))
....@@ -1262,7 +1307,8 @@
12621307 
12631308 static const struct k_clock clock_realtime = {
12641309 	.clock_getres		= posix_get_hrtimer_res,
1265
-	.clock_get		= posix_clock_realtime_get,
1310
+	.clock_get_timespec	= posix_get_realtime_timespec,
1311
+	.clock_get_ktime	= posix_get_realtime_ktime,
12661312 	.clock_set		= posix_clock_realtime_set,
12671313 	.clock_adj		= posix_clock_realtime_adj,
12681314 	.nsleep			= common_nsleep,
....@@ -1274,13 +1320,15 @@
12741320 	.timer_forward		= common_hrtimer_forward,
12751321 	.timer_remaining	= common_hrtimer_remaining,
12761322 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1323
+	.timer_wait_running	= common_timer_wait_running,
12771324 	.timer_arm		= common_hrtimer_arm,
12781325 };
12791326 
12801327 static const struct k_clock clock_monotonic = {
12811328 	.clock_getres		= posix_get_hrtimer_res,
1282
-	.clock_get		= posix_ktime_get_ts,
1283
-	.nsleep			= common_nsleep,
1329
+	.clock_get_timespec	= posix_get_monotonic_timespec,
1330
+	.clock_get_ktime	= posix_get_monotonic_ktime,
1331
+	.nsleep			= common_nsleep_timens,
12841332 	.timer_create		= common_timer_create,
12851333 	.timer_set		= common_timer_set,
12861334 	.timer_get		= common_timer_get,
....@@ -1289,27 +1337,29 @@
12891337 	.timer_forward		= common_hrtimer_forward,
12901338 	.timer_remaining	= common_hrtimer_remaining,
12911339 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1340
+	.timer_wait_running	= common_timer_wait_running,
12921341 	.timer_arm		= common_hrtimer_arm,
12931342 };
12941343 
12951344 static const struct k_clock clock_monotonic_raw = {
12961345 	.clock_getres		= posix_get_hrtimer_res,
1297
-	.clock_get		= posix_get_monotonic_raw,
1346
+	.clock_get_timespec	= posix_get_monotonic_raw,
12981347 };
12991348 
13001349 static const struct k_clock clock_realtime_coarse = {
13011350 	.clock_getres		= posix_get_coarse_res,
1302
-	.clock_get		= posix_get_realtime_coarse,
1351
+	.clock_get_timespec	= posix_get_realtime_coarse,
13031352 };
13041353 
13051354 static const struct k_clock clock_monotonic_coarse = {
13061355 	.clock_getres		= posix_get_coarse_res,
1307
-	.clock_get		= posix_get_monotonic_coarse,
1356
+	.clock_get_timespec	= posix_get_monotonic_coarse,
13081357 };
13091358 
13101359 static const struct k_clock clock_tai = {
13111360 	.clock_getres		= posix_get_hrtimer_res,
1312
-	.clock_get		= posix_get_tai,
1361
+	.clock_get_ktime	= posix_get_tai_ktime,
1362
+	.clock_get_timespec	= posix_get_tai_timespec,
13131363 	.nsleep			= common_nsleep,
13141364 	.timer_create		= common_timer_create,
13151365 	.timer_set		= common_timer_set,
....@@ -1319,13 +1369,15 @@
13191369 	.timer_forward		= common_hrtimer_forward,
13201370 	.timer_remaining	= common_hrtimer_remaining,
13211371 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1372
+	.timer_wait_running	= common_timer_wait_running,
13221373 	.timer_arm		= common_hrtimer_arm,
13231374 };
13241375 
13251376 static const struct k_clock clock_boottime = {
13261377 	.clock_getres		= posix_get_hrtimer_res,
1327
-	.clock_get		= posix_get_boottime,
1328
-	.nsleep			= common_nsleep,
1378
+	.clock_get_ktime	= posix_get_boottime_ktime,
1379
+	.clock_get_timespec	= posix_get_boottime_timespec,
1380
+	.nsleep			= common_nsleep_timens,
13291381 	.timer_create		= common_timer_create,
13301382 	.timer_set		= common_timer_set,
13311383 	.timer_get		= common_timer_get,
....@@ -1334,6 +1386,7 @@
13341386 	.timer_forward		= common_hrtimer_forward,
13351387 	.timer_remaining	= common_hrtimer_remaining,
13361388 	.timer_try_to_cancel	= common_hrtimer_try_to_cancel,
1389
+	.timer_wait_running	= common_timer_wait_running,
13371390 	.timer_arm		= common_hrtimer_arm,
13381391 };
13391392