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