[linux-2.6-block.git] / kernel / time / posix-stubs.c

/*
 * Dummy stubs used when CONFIG_POSIX_TIMERS=n
 *
 * Created by:  Nicolas Pitre, July 2016
 * Copyright:   (C) 2016 Linaro Limited
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/linkage.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/syscalls.h>
#include <linux/ktime.h>
#include <linux/timekeeping.h>
#include <linux/posix-timers.h>
#include <linux/compat.h>

#ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
/* Architectures may override SYS_NI and COMPAT_SYS_NI */
#include <asm/syscall_wrapper.h>
#endif

asmlinkage long sys_ni_posix_timers(void)
{
	pr_err_once("process %d (%s) attempted a POSIX timer syscall "
		    "while CONFIG_POSIX_TIMERS is not set\n",
		    current->pid, current->comm);
	return -ENOSYS;
}

#ifndef SYS_NI
#define SYS_NI(name)  SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers)
#endif

#ifndef COMPAT_SYS_NI
#define COMPAT_SYS_NI(name)  SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers)
#endif

SYS_NI(timer_create);
SYS_NI(timer_gettime);
SYS_NI(timer_getoverrun);
SYS_NI(timer_settime);
SYS_NI(timer_delete);
SYS_NI(clock_adjtime);
SYS_NI(getitimer);
SYS_NI(setitimer);
#ifdef __ARCH_WANT_SYS_ALARM
SYS_NI(alarm);
#endif

/*
 * We preserve minimal support for CLOCK_REALTIME and CLOCK_MONOTONIC
 * as it is easy to remain compatible with little code. CLOCK_BOOTTIME
 * is also included for convenience as at least systemd uses it.
 */

SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
		const struct __kernel_timespec __user *, tp)
{
	struct timespec64 new_tp;

	if (which_clock != CLOCK_REALTIME)
		return -EINVAL;
	if (get_timespec64(&new_tp, tp))
		return -EFAULT;

	return do_sys_settimeofday64(&new_tp, NULL);
}

int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
{
	switch (which_clock) {
	case CLOCK_REALTIME:
		ktime_get_real_ts64(tp);
		break;
	case CLOCK_MONOTONIC:
		ktime_get_ts64(tp);
		break;
	case CLOCK_BOOTTIME:
		ktime_get_boottime_ts64(tp);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}
SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
		struct __kernel_timespec __user *, tp)
{
	int ret;
	struct timespec64 kernel_tp;

	ret = do_clock_gettime(which_clock, &kernel_tp);
	if (ret)
		return ret;

	if (put_timespec64(&kernel_tp, tp))
		return -EFAULT;
	return 0;
}

SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct __kernel_timespec __user *, tp)
{
	struct timespec64 rtn_tp = {
		.tv_sec = 0,
		.tv_nsec = hrtimer_resolution,
	};

	switch (which_clock) {
	case CLOCK_REALTIME:
	case CLOCK_MONOTONIC:
	case CLOCK_BOOTTIME:
		if (put_timespec64(&rtn_tp, tp))
			return -EFAULT;
		return 0;
	default:
		return -EINVAL;
	}
}

SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
		const struct __kernel_timespec __user *, rqtp,
		struct __kernel_timespec __user *, rmtp)
{
	struct timespec64 t;

	switch (which_clock) {
	case CLOCK_REALTIME:
	case CLOCK_MONOTONIC:
	case CLOCK_BOOTTIME:
		break;
	default:
		return -EINVAL;
	}

	if (get_timespec64(&t, rqtp))
		return -EFAULT;
	if (!timespec64_valid(&t))
		return -EINVAL;
	if (flags & TIMER_ABSTIME)
		rmtp = NULL;
	current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
	current->restart_block.nanosleep.rmtp = rmtp;
	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
				 which_clock);
}

#ifdef CONFIG_COMPAT
COMPAT_SYS_NI(timer_create);
COMPAT_SYS_NI(clock_adjtime);
COMPAT_SYS_NI(timer_settime);
COMPAT_SYS_NI(timer_gettime);
COMPAT_SYS_NI(getitimer);
COMPAT_SYS_NI(setitimer);
#endif

#ifdef CONFIG_COMPAT_32BIT_TIME
COMPAT_SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
		       struct old_timespec32 __user *, tp)
{
	struct timespec64 new_tp;

	if (which_clock != CLOCK_REALTIME)
		return -EINVAL;
	if (get_old_timespec32(&new_tp, tp))
		return -EFAULT;

	return do_sys_settimeofday64(&new_tp, NULL);
}

COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
		       struct old_timespec32 __user *, tp)
{
	int ret;
	struct timespec64 kernel_tp;

	ret = do_clock_gettime(which_clock, &kernel_tp);
	if (ret)
		return ret;

	if (put_old_timespec32(&kernel_tp, tp))
		return -EFAULT;
	return 0;
}

COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
		       struct old_timespec32 __user *, tp)
{
	struct timespec64 rtn_tp = {
		.tv_sec = 0,
		.tv_nsec = hrtimer_resolution,
	};

	switch (which_clock) {
	case CLOCK_REALTIME:
	case CLOCK_MONOTONIC:
	case CLOCK_BOOTTIME:
		if (put_old_timespec32(&rtn_tp, tp))
			return -EFAULT;
		return 0;
	default:
		return -EINVAL;
	}
}

COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
		       struct old_timespec32 __user *, rqtp,
		       struct old_timespec32 __user *, rmtp)
{
	struct timespec64 t;

	switch (which_clock) {
	case CLOCK_REALTIME:
	case CLOCK_MONOTONIC:
	case CLOCK_BOOTTIME:
		break;
	default:
		return -EINVAL;
	}

	if (get_old_timespec32(&t, rqtp))
		return -EFAULT;
	if (!timespec64_valid(&t))
		return -EINVAL;
	if (flags & TIMER_ABSTIME)
		rmtp = NULL;
	current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
	current->restart_block.nanosleep.compat_rmtp = rmtp;
	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
				 which_clock);
}
#endif
Commit	Line	Data
baa73d9e NP	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>
edbeda46	20	#include <linux/compat.h>
baa73d9e	21
7303e30e DB	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
baa73d9e NP	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
7303e30e	35	#ifndef SYS_NI
baa73d9e	36	#define SYS_NI(name) SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers)
7303e30e DB	37	#endif
	38
	39	#ifndef COMPAT_SYS_NI
3a4d44b6	40	#define COMPAT_SYS_NI(name) SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers)
7303e30e	41	#endif
baa73d9e NP	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,
6d5b8413	62	const struct __kernel_timespec __user *, tp)
baa73d9e	63	{
5c499410	64	struct timespec64 new_tp;
baa73d9e NP	65
	66	if (which_clock != CLOCK_REALTIME)
	67	return -EINVAL;
5c499410	68	if (get_timespec64(&new_tp, tp))
baa73d9e	69	return -EFAULT;
2ac00f17	70
5c499410	71	return do_sys_settimeofday64(&new_tp, NULL);
baa73d9e NP	72	}
baa73d9e NP	73
5c499410	74	int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
baa73d9e	75	{
baa73d9e	76	switch (which_clock) {
5c499410 DD	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:
58a10456	84	ktime_get_boottime_ts64(tp);
5c499410 DD	85	break;
	86	default:
	87	return -EINVAL;
baa73d9e	88	}
3c9c12f4	89
5c499410 DD	90	return 0;
	91	}
	92	SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
6d5b8413	93	struct __kernel_timespec __user *, tp)
5c499410 DD	94	{
	95	int ret;
	96	struct timespec64 kernel_tp;
	97
	98	ret = do_clock_gettime(which_clock, &kernel_tp);
	99	if (ret)
	100	return ret;
	101
	102	if (put_timespec64(&kernel_tp, tp))
baa73d9e NP	103	return -EFAULT;
	104	return 0;
	105	}
	106
6d5b8413	107	SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct __kernel_timespec __user *, tp)
baa73d9e	108	{
5c499410	109	struct timespec64 rtn_tp = {
baa73d9e NP	110	.tv_sec = 0,
	111	.tv_nsec = hrtimer_resolution,
	112	};
	113
	114	switch (which_clock) {
	115	case CLOCK_REALTIME:
	116	case CLOCK_MONOTONIC:
	117	case CLOCK_BOOTTIME:
5c499410	118	if (put_timespec64(&rtn_tp, tp))
baa73d9e NP	119	return -EFAULT;
	120	return 0;
	121	default:
	122	return -EINVAL;
	123	}
	124	}
	125
	126	SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
01909974 DD	127	const struct __kernel_timespec __user *, rqtp,
01909974 DD	128	struct __kernel_timespec __user *, rmtp)
baa73d9e	129	{
fe460423	130	struct timespec64 t;
baa73d9e NP	131
	132	switch (which_clock) {
	133	case CLOCK_REALTIME:
	134	case CLOCK_MONOTONIC:
	135	case CLOCK_BOOTTIME:
edbeda46	136	break;
baa73d9e NP	137	default:
	138	return -EINVAL;
	139	}
edbeda46	140
fe460423	141	if (get_timespec64(&t, rqtp))
edbeda46	142	return -EFAULT;
fe460423	143	if (!timespec64_valid(&t))
edbeda46 AV	144	return -EINVAL;
	145	if (flags & TIMER_ABSTIME)
	146	rmtp = NULL;
	147	current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
	148	current->restart_block.nanosleep.rmtp = rmtp;
fe460423	149	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
edbeda46 AV	150	HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
edbeda46 AV	151	which_clock);
baa73d9e NP	152	}
	153
	154	#ifdef CONFIG_COMPAT
63a766a1 DD	155	COMPAT_SYS_NI(timer_create);
	156	COMPAT_SYS_NI(clock_adjtime);
	157	COMPAT_SYS_NI(timer_settime);
	158	COMPAT_SYS_NI(timer_gettime);
	159	COMPAT_SYS_NI(getitimer);
	160	COMPAT_SYS_NI(setitimer);
b5793b0d	161	#endif
63a766a1	162
b5793b0d	163	#ifdef CONFIG_COMPAT_32BIT_TIME
d822cdcc	164	COMPAT_SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
9afc5eee	165	struct old_timespec32 __user *, tp)
d822cdcc	166	{
5c499410	167	struct timespec64 new_tp;
d822cdcc AV	168
	169	if (which_clock != CLOCK_REALTIME)
	170	return -EINVAL;
9afc5eee	171	if (get_old_timespec32(&new_tp, tp))
d822cdcc AV	172	return -EFAULT;
d822cdcc AV	173
5c499410	174	return do_sys_settimeofday64(&new_tp, NULL);
d822cdcc AV	175	}
d822cdcc AV	176
5c499410	177	COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
9afc5eee	178	struct old_timespec32 __user *, tp)
d822cdcc	179	{
5c499410 DD	180	int ret;
5c499410 DD	181	struct timespec64 kernel_tp;
d822cdcc	182
5c499410 DD	183	ret = do_clock_gettime(which_clock, &kernel_tp);
	184	if (ret)
	185	return ret;
d822cdcc	186
9afc5eee	187	if (put_old_timespec32(&kernel_tp, tp))
d822cdcc AV	188	return -EFAULT;
	189	return 0;
	190	}
	191
5c499410	192	COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
9afc5eee	193	struct old_timespec32 __user *, tp)
d822cdcc	194	{
5c499410	195	struct timespec64 rtn_tp = {
d822cdcc AV	196	.tv_sec = 0,
	197	.tv_nsec = hrtimer_resolution,
	198	};
	199
	200	switch (which_clock) {
	201	case CLOCK_REALTIME:
	202	case CLOCK_MONOTONIC:
	203	case CLOCK_BOOTTIME:
9afc5eee	204	if (put_old_timespec32(&rtn_tp, tp))
d822cdcc AV	205	return -EFAULT;
	206	return 0;
	207	default:
	208	return -EINVAL;
	209	}
	210	}
5c499410	211
edbeda46	212	COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
9afc5eee AB	213	struct old_timespec32 __user *, rqtp,
9afc5eee AB	214	struct old_timespec32 __user *, rmtp)
baa73d9e	215	{
fe460423	216	struct timespec64 t;
edbeda46 AV	217
	218	switch (which_clock) {
	219	case CLOCK_REALTIME:
	220	case CLOCK_MONOTONIC:
	221	case CLOCK_BOOTTIME:
	222	break;
	223	default:
	224	return -EINVAL;
	225	}
	226
9afc5eee	227	if (get_old_timespec32(&t, rqtp))
edbeda46	228	return -EFAULT;
fe460423	229	if (!timespec64_valid(&t))
edbeda46 AV	230	return -EINVAL;
	231	if (flags & TIMER_ABSTIME)
	232	rmtp = NULL;
	233	current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
	234	current->restart_block.nanosleep.compat_rmtp = rmtp;
fe460423	235	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
edbeda46 AV	236	HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
edbeda46 AV	237	which_clock);
baa73d9e NP	238	}
baa73d9e NP	239	#endif