kernel/time/posix-stubs.c

   1 /*
   2  * Dummy stubs used when CONFIG_POSIX_TIMERS=n
   3  *
   4  * Created by:  Nicolas Pitre, July 2016
   5  * Copyright:   (C) 2016 Linaro Limited
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/linkage.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/errno.h>
  16 #include <linux/syscalls.h>
  17 #include <linux/ktime.h>
  18 #include <linux/timekeeping.h>
  19 #include <linux/posix-timers.h>
  20 #include <linux/compat.h>
  21
  22 #ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
  23 /* Architectures may override SYS_NI and COMPAT_SYS_NI */
  24 #include <asm/syscall_wrapper.h>
  25 #endif
  26
  27 asmlinkage long sys_ni_posix_timers(void)
  28 {
  29         pr_err_once("process %d (%s) attempted a POSIX timer syscall "
  30                     "while CONFIG_POSIX_TIMERS is not set\n",
  31                     current->pid, current->comm);
  32         return -ENOSYS;
  33 }
  34
  35 #ifndef SYS_NI
  36 #define SYS_NI(name)  SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers)
  37 #endif
  38
  39 #ifndef COMPAT_SYS_NI
  40 #define COMPAT_SYS_NI(name)  SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers)
  41 #endif
  42
  43 SYS_NI(timer_create);
  44 SYS_NI(timer_gettime);
  45 SYS_NI(timer_getoverrun);
  46 SYS_NI(timer_settime);
  47 SYS_NI(timer_delete);
  48 SYS_NI(clock_adjtime);
  49 SYS_NI(getitimer);
  50 SYS_NI(setitimer);
  51 #ifdef __ARCH_WANT_SYS_ALARM
  52 SYS_NI(alarm);
  53 #endif
  54
  55 /*
  56  * We preserve minimal support for CLOCK_REALTIME and CLOCK_MONOTONIC
  57  * as it is easy to remain compatible with little code. CLOCK_BOOTTIME
  58  * is also included for convenience as at least systemd uses it.
  59  */
  60
  61 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
  62                 const struct timespec __user *, tp)
  63 {
  64         struct timespec64 new_tp;
  65
  66         if (which_clock != CLOCK_REALTIME)
  67                 return -EINVAL;
  68         if (get_timespec64(&new_tp, tp))
  69                 return -EFAULT;
  70
  71         return do_sys_settimeofday64(&new_tp, NULL);
  72 }
  73
  74 int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
  75 {
  76         switch (which_clock) {
  77         case CLOCK_REALTIME:
  78                 ktime_get_real_ts64(tp);
  79                 break;
  80         case CLOCK_MONOTONIC:
  81                 ktime_get_ts64(tp);
  82                 break;
  83         case CLOCK_BOOTTIME:
  84                 get_monotonic_boottime64(tp);
  85                 break;
  86         case CLOCK_MONOTONIC_ACTIVE:
  87                 ktime_get_active_ts64(tp);
  88         default:
  89                 return -EINVAL;
  90         }
  91
  92         return 0;
  93 }
  94 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
  95                 struct timespec __user *, tp)
  96 {
  97         int ret;
  98         struct timespec64 kernel_tp;
  99
 100         ret = do_clock_gettime(which_clock, &kernel_tp);
 101         if (ret)
 102                 return ret;
 103
 104         if (put_timespec64(&kernel_tp, tp))
 105                 return -EFAULT;
 106         return 0;
 107 }
 108
 109 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct timespec __user *, tp)
 110 {
 111         struct timespec64 rtn_tp = {
 112                 .tv_sec = 0,
 113                 .tv_nsec = hrtimer_resolution,
 114         };
 115
 116         switch (which_clock) {
 117         case CLOCK_REALTIME:
 118         case CLOCK_MONOTONIC:
 119         case CLOCK_BOOTTIME:
 120                 if (put_timespec64(&rtn_tp, tp))
 121                         return -EFAULT;
 122                 return 0;
 123         default:
 124                 return -EINVAL;
 125         }
 126 }
 127
 128 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
 129                 const struct timespec __user *, rqtp,
 130                 struct timespec __user *, rmtp)
 131 {
 132         struct timespec64 t;
 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.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
 150         current->restart_block.nanosleep.rmtp = rmtp;
 151         return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
 152                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 153                                  which_clock);
 154 }
 155
 156 #ifdef CONFIG_COMPAT
 157 COMPAT_SYS_NI(timer_create);
 158 COMPAT_SYS_NI(clock_adjtime);
 159 COMPAT_SYS_NI(timer_settime);
 160 COMPAT_SYS_NI(timer_gettime);
 161 COMPAT_SYS_NI(getitimer);
 162 COMPAT_SYS_NI(setitimer);
 163 #endif
 164
 165 #ifdef CONFIG_COMPAT_32BIT_TIME
 166 COMPAT_SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
 167                        struct compat_timespec __user *, tp)
 168 {
 169         struct timespec64 new_tp;
 170
 171         if (which_clock != CLOCK_REALTIME)
 172                 return -EINVAL;
 173         if (compat_get_timespec64(&new_tp, tp))
 174                 return -EFAULT;
 175
 176         return do_sys_settimeofday64(&new_tp, NULL);
 177 }
 178
 179 COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
 180                        struct compat_timespec __user *, tp)
 181 {
 182         int ret;
 183         struct timespec64 kernel_tp;
 184
 185         ret = do_clock_gettime(which_clock, &kernel_tp);
 186         if (ret)
 187                 return ret;
 188
 189         if (compat_put_timespec64(&kernel_tp, tp))
 190                 return -EFAULT;
 191         return 0;
 192 }
 193
 194 COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
 195                        struct compat_timespec __user *, tp)
 196 {
 197         struct timespec64 rtn_tp = {
 198                 .tv_sec = 0,
 199                 .tv_nsec = hrtimer_resolution,
 200         };
 201
 202         switch (which_clock) {
 203         case CLOCK_REALTIME:
 204         case CLOCK_MONOTONIC:
 205         case CLOCK_BOOTTIME:
 206                 if (compat_put_timespec64(&rtn_tp, tp))
 207                         return -EFAULT;
 208                 return 0;
 209         default:
 210                 return -EINVAL;
 211         }
 212 }
 213
 214 COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
 215                        struct compat_timespec __user *, rqtp,
 216                        struct compat_timespec __user *, rmtp)
 217 {
 218         struct timespec64 t;
 219
 220         switch (which_clock) {
 221         case CLOCK_REALTIME:
 222         case CLOCK_MONOTONIC:
 223         case CLOCK_BOOTTIME:
 224                 break;
 225         default:
 226                 return -EINVAL;
 227         }
 228
 229         if (compat_get_timespec64(&t, rqtp))
 230                 return -EFAULT;
 231         if (!timespec64_valid(&t))
 232                 return -EINVAL;
 233         if (flags & TIMER_ABSTIME)
 234                 rmtp = NULL;
 235         current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
 236         current->restart_block.nanosleep.compat_rmtp = rmtp;
 237         return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
 238                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
 239                                  which_clock);
 240 }
 241 #endif