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/compat.h> 18 19 #ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER 20 /* Architectures may override SYS_NI and COMPAT_SYS_NI */ 21 #include <asm/syscall_wrapper.h> 22 #endif 23 24 asmlinkage long sys_ni_posix_timers(void) 25 { 26 pr_err_once("process %d (%s) attempted a POSIX timer syscall " 27 "while CONFIG_POSIX_TIMERS is not set\n", 28 current->pid, current->comm); 29 return -ENOSYS; 30 } 31 32 #ifndef SYS_NI 33 #define SYS_NI(name) SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers) 34 #endif 35 36 #ifndef COMPAT_SYS_NI 37 #define COMPAT_SYS_NI(name) SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers) 38 #endif 39 40 SYS_NI(timer_create); 41 SYS_NI(timer_gettime); 42 SYS_NI(timer_getoverrun); 43 SYS_NI(timer_settime); 44 SYS_NI(timer_delete); 45 SYS_NI(clock_adjtime); 46 SYS_NI(getitimer); 47 SYS_NI(setitimer); 48 SYS_NI(clock_adjtime32); 49 #ifdef __ARCH_WANT_SYS_ALARM 50 SYS_NI(alarm); 51 #endif 52 53 /* 54 * We preserve minimal support for CLOCK_REALTIME and CLOCK_MONOTONIC 55 * as it is easy to remain compatible with little code. CLOCK_BOOTTIME 56 * is also included for convenience as at least systemd uses it. 57 */ 58 59 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, 60 const struct __kernel_timespec __user *, tp) 61 { 62 struct timespec64 new_tp; 63 64 if (which_clock != CLOCK_REALTIME) 65 return -EINVAL; 66 if (get_timespec64(&new_tp, tp)) 67 return -EFAULT; 68 69 return do_sys_settimeofday64(&new_tp, NULL); 70 } 71 72 int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp) 73 { 74 switch (which_clock) { 75 case CLOCK_REALTIME: 76 ktime_get_real_ts64(tp); 77 break; 78 case CLOCK_MONOTONIC: 79 ktime_get_ts64(tp); 80 break; 81 case CLOCK_BOOTTIME: 82 ktime_get_boottime_ts64(tp); 83 break; 84 default: 85 return -EINVAL; 86 } 87 88 return 0; 89 } 90 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, 91 struct __kernel_timespec __user *, tp) 92 { 93 int ret; 94 struct timespec64 kernel_tp; 95 96 ret = do_clock_gettime(which_clock, &kernel_tp); 97 if (ret) 98 return ret; 99 100 if (put_timespec64(&kernel_tp, tp)) 101 return -EFAULT; 102 return 0; 103 } 104 105 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct __kernel_timespec __user *, tp) 106 { 107 struct timespec64 rtn_tp = { 108 .tv_sec = 0, 109 .tv_nsec = hrtimer_resolution, 110 }; 111 112 switch (which_clock) { 113 case CLOCK_REALTIME: 114 case CLOCK_MONOTONIC: 115 case CLOCK_BOOTTIME: 116 if (put_timespec64(&rtn_tp, tp)) 117 return -EFAULT; 118 return 0; 119 default: 120 return -EINVAL; 121 } 122 } 123 124 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 125 const struct __kernel_timespec __user *, rqtp, 126 struct __kernel_timespec __user *, rmtp) 127 { 128 struct timespec64 t; 129 130 switch (which_clock) { 131 case CLOCK_REALTIME: 132 case CLOCK_MONOTONIC: 133 case CLOCK_BOOTTIME: 134 break; 135 default: 136 return -EINVAL; 137 } 138 139 if (get_timespec64(&t, rqtp)) 140 return -EFAULT; 141 if (!timespec64_valid(&t)) 142 return -EINVAL; 143 if (flags & TIMER_ABSTIME) 144 rmtp = NULL; 145 current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE; 146 current->restart_block.nanosleep.rmtp = rmtp; 147 return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ? 148 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 149 which_clock); 150 } 151 152 #ifdef CONFIG_COMPAT 153 COMPAT_SYS_NI(timer_create); 154 COMPAT_SYS_NI(getitimer); 155 COMPAT_SYS_NI(setitimer); 156 #endif 157 158 #ifdef CONFIG_COMPAT_32BIT_TIME 159 SYS_NI(timer_settime32); 160 SYS_NI(timer_gettime32); 161 162 SYSCALL_DEFINE2(clock_settime32, const clockid_t, which_clock, 163 struct old_timespec32 __user *, tp) 164 { 165 struct timespec64 new_tp; 166 167 if (which_clock != CLOCK_REALTIME) 168 return -EINVAL; 169 if (get_old_timespec32(&new_tp, tp)) 170 return -EFAULT; 171 172 return do_sys_settimeofday64(&new_tp, NULL); 173 } 174 175 SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock, 176 struct old_timespec32 __user *, tp) 177 { 178 int ret; 179 struct timespec64 kernel_tp; 180 181 ret = do_clock_gettime(which_clock, &kernel_tp); 182 if (ret) 183 return ret; 184 185 if (put_old_timespec32(&kernel_tp, tp)) 186 return -EFAULT; 187 return 0; 188 } 189 190 SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock, 191 struct old_timespec32 __user *, tp) 192 { 193 struct timespec64 rtn_tp = { 194 .tv_sec = 0, 195 .tv_nsec = hrtimer_resolution, 196 }; 197 198 switch (which_clock) { 199 case CLOCK_REALTIME: 200 case CLOCK_MONOTONIC: 201 case CLOCK_BOOTTIME: 202 if (put_old_timespec32(&rtn_tp, tp)) 203 return -EFAULT; 204 return 0; 205 default: 206 return -EINVAL; 207 } 208 } 209 210 SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags, 211 struct old_timespec32 __user *, rqtp, 212 struct old_timespec32 __user *, rmtp) 213 { 214 struct timespec64 t; 215 216 switch (which_clock) { 217 case CLOCK_REALTIME: 218 case CLOCK_MONOTONIC: 219 case CLOCK_BOOTTIME: 220 break; 221 default: 222 return -EINVAL; 223 } 224 225 if (get_old_timespec32(&t, rqtp)) 226 return -EFAULT; 227 if (!timespec64_valid(&t)) 228 return -EINVAL; 229 if (flags & TIMER_ABSTIME) 230 rmtp = NULL; 231 current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE; 232 current->restart_block.nanosleep.compat_rmtp = rmtp; 233 return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ? 234 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 235 which_clock); 236 } 237 #endif 238