1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Dummy stubs used when CONFIG_POSIX_TIMERS=n 4 * 5 * Created by: Nicolas Pitre, July 2016 6 * Copyright: (C) 2016 Linaro Limited 7 */ 8 9 #include <linux/linkage.h> 10 #include <linux/kernel.h> 11 #include <linux/sched.h> 12 #include <linux/errno.h> 13 #include <linux/syscalls.h> 14 #include <linux/ktime.h> 15 #include <linux/timekeeping.h> 16 #include <linux/posix-timers.h> 17 #include <linux/time_namespace.h> 18 #include <linux/compat.h> 19 20 /* 21 * We preserve minimal support for CLOCK_REALTIME and CLOCK_MONOTONIC 22 * as it is easy to remain compatible with little code. CLOCK_BOOTTIME 23 * is also included for convenience as at least systemd uses it. 24 */ 25 26 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, 27 const struct __kernel_timespec __user *, tp) 28 { 29 struct timespec64 new_tp; 30 31 if (which_clock != CLOCK_REALTIME) 32 return -EINVAL; 33 if (get_timespec64(&new_tp, tp)) 34 return -EFAULT; 35 36 return do_sys_settimeofday64(&new_tp, NULL); 37 } 38 39 static int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp) 40 { 41 switch (which_clock) { 42 case CLOCK_REALTIME: 43 ktime_get_real_ts64(tp); 44 break; 45 case CLOCK_MONOTONIC: 46 ktime_get_ts64(tp); 47 timens_add_monotonic(tp); 48 break; 49 case CLOCK_BOOTTIME: 50 ktime_get_boottime_ts64(tp); 51 timens_add_boottime(tp); 52 break; 53 default: 54 return -EINVAL; 55 } 56 57 return 0; 58 } 59 60 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, 61 struct __kernel_timespec __user *, tp) 62 { 63 int ret; 64 struct timespec64 kernel_tp; 65 66 ret = do_clock_gettime(which_clock, &kernel_tp); 67 if (ret) 68 return ret; 69 70 if (put_timespec64(&kernel_tp, tp)) 71 return -EFAULT; 72 return 0; 73 } 74 75 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct __kernel_timespec __user *, tp) 76 { 77 struct timespec64 rtn_tp = { 78 .tv_sec = 0, 79 .tv_nsec = hrtimer_resolution, 80 }; 81 82 switch (which_clock) { 83 case CLOCK_REALTIME: 84 case CLOCK_MONOTONIC: 85 case CLOCK_BOOTTIME: 86 if (put_timespec64(&rtn_tp, tp)) 87 return -EFAULT; 88 return 0; 89 default: 90 return -EINVAL; 91 } 92 } 93 94 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 95 const struct __kernel_timespec __user *, rqtp, 96 struct __kernel_timespec __user *, rmtp) 97 { 98 struct timespec64 t; 99 ktime_t texp; 100 101 switch (which_clock) { 102 case CLOCK_REALTIME: 103 case CLOCK_MONOTONIC: 104 case CLOCK_BOOTTIME: 105 break; 106 default: 107 return -EINVAL; 108 } 109 110 if (get_timespec64(&t, rqtp)) 111 return -EFAULT; 112 if (!timespec64_valid(&t)) 113 return -EINVAL; 114 if (flags & TIMER_ABSTIME) 115 rmtp = NULL; 116 current->restart_block.fn = do_no_restart_syscall; 117 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE; 118 current->restart_block.nanosleep.rmtp = rmtp; 119 texp = timespec64_to_ktime(t); 120 if (flags & TIMER_ABSTIME) 121 texp = timens_ktime_to_host(which_clock, texp); 122 return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ? 123 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 124 which_clock); 125 } 126 127 #ifdef CONFIG_COMPAT_32BIT_TIME 128 129 SYSCALL_DEFINE2(clock_settime32, const clockid_t, which_clock, 130 struct old_timespec32 __user *, tp) 131 { 132 struct timespec64 new_tp; 133 134 if (which_clock != CLOCK_REALTIME) 135 return -EINVAL; 136 if (get_old_timespec32(&new_tp, tp)) 137 return -EFAULT; 138 139 return do_sys_settimeofday64(&new_tp, NULL); 140 } 141 142 SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock, 143 struct old_timespec32 __user *, tp) 144 { 145 int ret; 146 struct timespec64 kernel_tp; 147 148 ret = do_clock_gettime(which_clock, &kernel_tp); 149 if (ret) 150 return ret; 151 152 if (put_old_timespec32(&kernel_tp, tp)) 153 return -EFAULT; 154 return 0; 155 } 156 157 SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock, 158 struct old_timespec32 __user *, tp) 159 { 160 struct timespec64 rtn_tp = { 161 .tv_sec = 0, 162 .tv_nsec = hrtimer_resolution, 163 }; 164 165 switch (which_clock) { 166 case CLOCK_REALTIME: 167 case CLOCK_MONOTONIC: 168 case CLOCK_BOOTTIME: 169 if (put_old_timespec32(&rtn_tp, tp)) 170 return -EFAULT; 171 return 0; 172 default: 173 return -EINVAL; 174 } 175 } 176 177 SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags, 178 struct old_timespec32 __user *, rqtp, 179 struct old_timespec32 __user *, rmtp) 180 { 181 struct timespec64 t; 182 ktime_t texp; 183 184 switch (which_clock) { 185 case CLOCK_REALTIME: 186 case CLOCK_MONOTONIC: 187 case CLOCK_BOOTTIME: 188 break; 189 default: 190 return -EINVAL; 191 } 192 193 if (get_old_timespec32(&t, rqtp)) 194 return -EFAULT; 195 if (!timespec64_valid(&t)) 196 return -EINVAL; 197 if (flags & TIMER_ABSTIME) 198 rmtp = NULL; 199 current->restart_block.fn = do_no_restart_syscall; 200 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE; 201 current->restart_block.nanosleep.compat_rmtp = rmtp; 202 texp = timespec64_to_ktime(t); 203 if (flags & TIMER_ABSTIME) 204 texp = timens_ktime_to_host(which_clock, texp); 205 return hrtimer_nanosleep(texp, flags & TIMER_ABSTIME ? 206 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 207 which_clock); 208 } 209 #endif 210