[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / x86_64 / kernel / vsyscall.c

/*
 *  linux/arch/x86_64/kernel/vsyscall.c
 *
 *  Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
 *  Copyright 2003 Andi Kleen, SuSE Labs.
 *
 *  Thanks to hpa@transmeta.com for some useful hint.
 *  Special thanks to Ingo Molnar for his early experience with
 *  a different vsyscall implementation for Linux/IA32 and for the name.
 *
 *  vsyscall 1 is located at -10Mbyte, vsyscall 2 is located
 *  at virtual address -10Mbyte+1024bytes etc... There are at max 4
 *  vsyscalls. One vsyscall can reserve more than 1 slot to avoid
 *  jumping out of line if necessary. We cannot add more with this
 *  mechanism because older kernels won't return -ENOSYS.
 *  If we want more than four we need a vDSO.
 *
 *  Note: the concept clashes with user mode linux. If you use UML and
 *  want per guest time just set the kernel.vsyscall64 sysctl to 0.
 */

#include <linux/time.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/seqlock.h>
#include <linux/jiffies.h>
#include <linux/sysctl.h>

#include <asm/vsyscall.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/fixmap.h>
#include <asm/errno.h>
#include <asm/io.h>

#define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr)))
#define force_inline __attribute__((always_inline)) inline

int __sysctl_vsyscall __section_sysctl_vsyscall = 1;
seqlock_t __xtime_lock __section_xtime_lock = SEQLOCK_UNLOCKED;

#include <asm/unistd.h>

static force_inline void timeval_normalize(struct timeval * tv)
{
	time_t __sec;

	__sec = tv->tv_usec / 1000000;
	if (__sec) {
		tv->tv_usec %= 1000000;
		tv->tv_sec += __sec;
	}
}

static force_inline void do_vgettimeofday(struct timeval * tv)
{
	long sequence, t;
	unsigned long sec, usec;

	do {
		sequence = read_seqbegin(&__xtime_lock);
		
		sec = __xtime.tv_sec;
		usec = (__xtime.tv_nsec / 1000) +
			(__jiffies - __wall_jiffies) * (1000000 / HZ);

		if (__vxtime.mode != VXTIME_HPET) {
			sync_core();
			rdtscll(t);
			if (t < __vxtime.last_tsc)
				t = __vxtime.last_tsc;
			usec += ((t - __vxtime.last_tsc) *
				 __vxtime.tsc_quot) >> 32;
			/* See comment in x86_64 do_gettimeofday. */
		} else {
			usec += ((readl((void *)fix_to_virt(VSYSCALL_HPET) + 0xf0) -
				  __vxtime.last) * __vxtime.quot) >> 32;
		}
	} while (read_seqretry(&__xtime_lock, sequence));

	tv->tv_sec = sec + usec / 1000000;
	tv->tv_usec = usec % 1000000;
}

/* RED-PEN may want to readd seq locking, but then the variable should be write-once. */
static force_inline void do_get_tz(struct timezone * tz)
{
	*tz = __sys_tz;
}

static force_inline int gettimeofday(struct timeval *tv, struct timezone *tz)
{
	int ret;
	asm volatile("vsysc2: syscall"
		: "=a" (ret)
		: "0" (__NR_gettimeofday),"D" (tv),"S" (tz) : __syscall_clobber );
	return ret;
}

static force_inline long time_syscall(long *t)
{
	long secs;
	asm volatile("vsysc1: syscall"
		: "=a" (secs)
		: "0" (__NR_time),"D" (t) : __syscall_clobber);
	return secs;
}

int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz)
{
	if (unlikely(!__sysctl_vsyscall))
		return gettimeofday(tv,tz);
	if (tv)
		do_vgettimeofday(tv);
	if (tz)
		do_get_tz(tz);
	return 0;
}

/* This will break when the xtime seconds get inaccurate, but that is
 * unlikely */
time_t __vsyscall(1) vtime(time_t *t)
{
	if (unlikely(!__sysctl_vsyscall))
		return time_syscall(t);
	else if (t)
		*t = __xtime.tv_sec;		
	return __xtime.tv_sec;
}

long __vsyscall(2) venosys_0(void)
{
	return -ENOSYS;
}

long __vsyscall(3) venosys_1(void)
{
	return -ENOSYS;
}

#ifdef CONFIG_SYSCTL

#define SYSCALL 0x050f
#define NOP2    0x9090

/*
 * NOP out syscall in vsyscall page when not needed.
 */
static int vsyscall_sysctl_change(ctl_table *ctl, int write, struct file * filp,
                        void __user *buffer, size_t *lenp, loff_t *ppos)
{
	extern u16 vsysc1, vsysc2;
	u16 *map1, *map2;
	int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
	if (!write)
		return ret;
	/* gcc has some trouble with __va(__pa()), so just do it this
	   way. */
	map1 = ioremap(__pa_symbol(&vsysc1), 2);
	if (!map1)
		return -ENOMEM;
	map2 = ioremap(__pa_symbol(&vsysc2), 2);
	if (!map2) {
		ret = -ENOMEM;
		goto out;
	}
	if (!sysctl_vsyscall) {
		*map1 = SYSCALL;
		*map2 = SYSCALL;
	} else {
		*map1 = NOP2;
		*map2 = NOP2;
	}
	iounmap(map2);
out:
	iounmap(map1);
	return ret;
}

static int vsyscall_sysctl_nostrat(ctl_table *t, int __user *name, int nlen,
				void __user *oldval, size_t __user *oldlenp,
				void __user *newval, size_t newlen,
				void **context)
{
	return -ENOSYS;
}

static ctl_table kernel_table2[] = {
	{ .ctl_name = 99, .procname = "vsyscall64",
	  .data = &sysctl_vsyscall, .maxlen = sizeof(int), .mode = 0644,
	  .strategy = vsyscall_sysctl_nostrat,
	  .proc_handler = vsyscall_sysctl_change },
	{ 0, }
};

static ctl_table kernel_root_table2[] = {
	{ .ctl_name = CTL_KERN, .procname = "kernel", .mode = 0555,
	  .child = kernel_table2 },
	{ 0 },
};

#endif

static void __init map_vsyscall(void)
{
	extern char __vsyscall_0;
	unsigned long physaddr_page0 = __pa_symbol(&__vsyscall_0);

	__set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
}

static int __init vsyscall_init(void)
{
	BUG_ON(((unsigned long) &vgettimeofday !=
			VSYSCALL_ADDR(__NR_vgettimeofday)));
	BUG_ON((unsigned long) &vtime != VSYSCALL_ADDR(__NR_vtime));
	BUG_ON((VSYSCALL_ADDR(0) != __fix_to_virt(VSYSCALL_FIRST_PAGE)));
	map_vsyscall();
#ifdef CONFIG_SYSCTL
	register_sysctl_table(kernel_root_table2, 0);
#endif
	return 0;
}

__initcall(vsyscall_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/x86_64/kernel/vsyscall.c
	3	*
	4	* Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
	5	* Copyright 2003 Andi Kleen, SuSE Labs.
	6	*
	7	* Thanks to hpa@transmeta.com for some useful hint.
	8	* Special thanks to Ingo Molnar for his early experience with
	9	* a different vsyscall implementation for Linux/IA32 and for the name.
	10	*
	11	* vsyscall 1 is located at -10Mbyte, vsyscall 2 is located
	12	* at virtual address -10Mbyte+1024bytes etc... There are at max 4
	13	* vsyscalls. One vsyscall can reserve more than 1 slot to avoid
	14	* jumping out of line if necessary. We cannot add more with this
	15	* mechanism because older kernels won't return -ENOSYS.
	16	* If we want more than four we need a vDSO.
	17	*
	18	* Note: the concept clashes with user mode linux. If you use UML and
	19	* want per guest time just set the kernel.vsyscall64 sysctl to 0.
	20	*/
	21
	22	#include <linux/time.h>
	23	#include <linux/init.h>
	24	#include <linux/kernel.h>
	25	#include <linux/timer.h>
	26	#include <linux/seqlock.h>
	27	#include <linux/jiffies.h>
	28	#include <linux/sysctl.h>
	29
	30	#include <asm/vsyscall.h>
	31	#include <asm/pgtable.h>
	32	#include <asm/page.h>
	33	#include <asm/fixmap.h>
	34	#include <asm/errno.h>
	35	#include <asm/io.h>
	36
	37	#define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr)))
	38	#define force_inline __attribute__((always_inline)) inline
	39
	40	int __sysctl_vsyscall __section_sysctl_vsyscall = 1;
	41	seqlock_t __xtime_lock __section_xtime_lock = SEQLOCK_UNLOCKED;
	42
	43	#include <asm/unistd.h>
	44
	45	static force_inline void timeval_normalize(struct timeval * tv)
	46	{
	47	time_t __sec;
	48
	49	__sec = tv->tv_usec / 1000000;
	50	if (__sec) {
	51	tv->tv_usec %= 1000000;
	52	tv->tv_sec += __sec;
	53	}
	54	}
	55
	56	static force_inline void do_vgettimeofday(struct timeval * tv)
	57	{
	58	long sequence, t;
	59	unsigned long sec, usec;
	60
	61	do {
	62	sequence = read_seqbegin(&__xtime_lock);
	63
	64	sec = __xtime.tv_sec;
65	usec = (__xtime.tv_nsec / 1000) +
66	(__jiffies - __wall_jiffies) * (1000000 / HZ);
67
312df5f1	68	if (__vxtime.mode != VXTIME_HPET) {
1da177e4 LT	69	sync_core();
	70	rdtscll(t);
	71	if (t < __vxtime.last_tsc)
	72	t = __vxtime.last_tsc;
	73	usec += ((t - __vxtime.last_tsc) *
	74	__vxtime.tsc_quot) >> 32;
	75	/* See comment in x86_64 do_gettimeofday. */
	76	} else {
	77	usec += ((readl((void *)fix_to_virt(VSYSCALL_HPET) + 0xf0) -
	78	__vxtime.last) * __vxtime.quot) >> 32;
	79	}
	80	} while (read_seqretry(&__xtime_lock, sequence));
	81
	82	tv->tv_sec = sec + usec / 1000000;
	83	tv->tv_usec = usec % 1000000;
	84	}
	85
	86	/* RED-PEN may want to readd seq locking, but then the variable should be write-once. */
	87	static force_inline void do_get_tz(struct timezone * tz)
	88	{
	89	*tz = __sys_tz;
	90	}
	91
	92	static force_inline int gettimeofday(struct timeval tv, struct timezone tz)
	93	{
	94	int ret;
	95	asm volatile("vsysc2: syscall"
	96	: "=a" (ret)
	97	: "0" (__NR_gettimeofday),"D" (tv),"S" (tz) : __syscall_clobber );
	98	return ret;
	99	}
	100
	101	static force_inline long time_syscall(long *t)
	102	{
	103	long secs;
	104	asm volatile("vsysc1: syscall"
	105	: "=a" (secs)
	106	: "0" (__NR_time),"D" (t) : __syscall_clobber);
	107	return secs;
	108	}
	109
2e8ad43e	110	int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz)
1da177e4 LT	111	{
	112	if (unlikely(!__sysctl_vsyscall))
	113	return gettimeofday(tv,tz);
	114	if (tv)
	115	do_vgettimeofday(tv);
	116	if (tz)
	117	do_get_tz(tz);
	118	return 0;
	119	}
	120
	121	/* This will break when the xtime seconds get inaccurate, but that is
	122	* unlikely */
2e8ad43e	123	time_t __vsyscall(1) vtime(time_t *t)
1da177e4 LT	124	{
	125	if (unlikely(!__sysctl_vsyscall))
	126	return time_syscall(t);
	127	else if (t)
	128	*t = __xtime.tv_sec;
	129	return __xtime.tv_sec;
	130	}
	131
2e8ad43e	132	long __vsyscall(2) venosys_0(void)
1da177e4 LT	133	{
	134	return -ENOSYS;
	135	}
	136
2e8ad43e	137	long __vsyscall(3) venosys_1(void)
1da177e4 LT	138	{
	139	return -ENOSYS;
	140	}
	141
	142	#ifdef CONFIG_SYSCTL
	143
	144	#define SYSCALL 0x050f
	145	#define NOP2 0x9090
	146
	147	/*
	148	* NOP out syscall in vsyscall page when not needed.
	149	*/
	150	static int vsyscall_sysctl_change(ctl_table ctl, int write, struct file filp,
	151	void __user buffer, size_t lenp, loff_t *ppos)
	152	{
	153	extern u16 vsysc1, vsysc2;
	154	u16 map1, map2;
	155	int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
	156	if (!write)
	157	return ret;
	158	/* gcc has some trouble with __va(__pa()), so just do it this
	159	way. */
	160	map1 = ioremap(__pa_symbol(&vsysc1), 2);
	161	if (!map1)
	162	return -ENOMEM;
	163	map2 = ioremap(__pa_symbol(&vsysc2), 2);
	164	if (!map2) {
	165	ret = -ENOMEM;
	166	goto out;
	167	}
	168	if (!sysctl_vsyscall) {
	169	*map1 = SYSCALL;
	170	*map2 = SYSCALL;
	171	} else {
	172	*map1 = NOP2;
	173	*map2 = NOP2;
	174	}
	175	iounmap(map2);
	176	out:
	177	iounmap(map1);
	178	return ret;
	179	}
	180
	181	static int vsyscall_sysctl_nostrat(ctl_table t, int __user name, int nlen,
	182	void __user oldval, size_t __user oldlenp,
	183	void __user *newval, size_t newlen,
	184	void **context)
	185	{
	186	return -ENOSYS;
	187	}
	188
	189	static ctl_table kernel_table2[] = {
	190	{ .ctl_name = 99, .procname = "vsyscall64",
	191	.data = &sysctl_vsyscall, .maxlen = sizeof(int), .mode = 0644,
	192	.strategy = vsyscall_sysctl_nostrat,
	193	.proc_handler = vsyscall_sysctl_change },
	194	{ 0, }
	195	};
	196
	197	static ctl_table kernel_root_table2[] = {
	198	{ .ctl_name = CTL_KERN, .procname = "kernel", .mode = 0555,
	199	.child = kernel_table2 },
	200	{ 0 },
	201	};
202
203	#endif
204
205	static void __init map_vsyscall(void)
206	{
207	extern char __vsyscall_0;
208	unsigned long physaddr_page0 = __pa_symbol(&__vsyscall_0);
209
210	__set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
211	}
212
213	static int __init vsyscall_init(void)
214	{
215	BUG_ON(((unsigned long) &vgettimeofday !=
216	VSYSCALL_ADDR(__NR_vgettimeofday)));
217	BUG_ON((unsigned long) &vtime != VSYSCALL_ADDR(__NR_vtime));
218	BUG_ON((VSYSCALL_ADDR(0) != __fix_to_virt(VSYSCALL_FIRST_PAGE)));
219	map_vsyscall();
f3c5f5e7	220	#ifdef CONFIG_SYSCTL
1da177e4	221	register_sysctl_table(kernel_root_table2, 0);
f3c5f5e7	222	#endif
1da177e4 LT	223	return 0;
	224	}
	225
	226	__initcall(vsyscall_init);