kernel/time/posix-stubs.c

   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.fn = do_no_restart_syscall;
 146         current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
 147         current->restart_block.nanosleep.rmtp = rmtp;
 148         return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
 149                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 150                                  which_clock);
 151 }
 152
 153 #ifdef CONFIG_COMPAT
 154 COMPAT_SYS_NI(timer_create);
 155 COMPAT_SYS_NI(getitimer);
 156 COMPAT_SYS_NI(setitimer);
 157 #endif
 158
 159 #ifdef CONFIG_COMPAT_32BIT_TIME
 160 SYS_NI(timer_settime32);
 161 SYS_NI(timer_gettime32);
 162
 163 SYSCALL_DEFINE2(clock_settime32, const clockid_t, which_clock,
 164                 struct old_timespec32 __user *, tp)
 165 {
 166         struct timespec64 new_tp;
 167
 168         if (which_clock != CLOCK_REALTIME)
 169                 return -EINVAL;
 170         if (get_old_timespec32(&new_tp, tp))
 171                 return -EFAULT;
 172
 173         return do_sys_settimeofday64(&new_tp, NULL);
 174 }
 175
 176 SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
 177                 struct old_timespec32 __user *, tp)
 178 {
 179         int ret;
 180         struct timespec64 kernel_tp;
 181
 182         ret = do_clock_gettime(which_clock, &kernel_tp);
 183         if (ret)
 184                 return ret;
 185
 186         if (put_old_timespec32(&kernel_tp, tp))
 187                 return -EFAULT;
 188         return 0;
 189 }
 190
 191 SYSCALL_DEFINE2(clock_getres_time32, clockid_t, which_clock,
 192                 struct old_timespec32 __user *, tp)
 193 {
 194         struct timespec64 rtn_tp = {
 195                 .tv_sec = 0,
 196                 .tv_nsec = hrtimer_resolution,
 197         };
 198
 199         switch (which_clock) {
 200         case CLOCK_REALTIME:
 201         case CLOCK_MONOTONIC:
 202         case CLOCK_BOOTTIME:
 203                 if (put_old_timespec32(&rtn_tp, tp))
 204                         return -EFAULT;
 205                 return 0;
 206         default:
 207                 return -EINVAL;
 208         }
 209 }
 210
 211 SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags,
 212                 struct old_timespec32 __user *, rqtp,
 213                 struct old_timespec32 __user *, rmtp)
 214 {
 215         struct timespec64 t;
 216
 217         switch (which_clock) {
 218         case CLOCK_REALTIME:
 219         case CLOCK_MONOTONIC:
 220         case CLOCK_BOOTTIME:
 221                 break;
 222         default:
 223                 return -EINVAL;
 224         }
 225
 226         if (get_old_timespec32(&t, rqtp))
 227                 return -EFAULT;
 228         if (!timespec64_valid(&t))
 229                 return -EINVAL;
 230         if (flags & TIMER_ABSTIME)
 231                 rmtp = NULL;
 232         current->restart_block.fn = do_no_restart_syscall;
 233         current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
 234         current->restart_block.nanosleep.compat_rmtp = rmtp;
 235         return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
 236                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 237                                  which_clock);
 238 }
 239 #endif