[PATCH] x86_64 merge: arch + asm
[opensuse:kernel.git] / arch / x86_64 / kernel / vsyscall.c
1 /*
2  *  linux/arch/x86_64/kernel/vsyscall.c
3  *
4  *  Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
5  *
6  *  Thanks to hpa@transmeta.com for some useful hint.
7  *  Special thanks to Ingo Molnar for his early experience with
8  *  a different vsyscall implementation for Linux/IA32 and for the name.
9  *
10  *  vsyscall 1 is located at -10Mbyte, vsyscall 2 is located
11  *  at virtual address -10Mbyte+1024bytes etc... There are at max 8192
12  *  vsyscalls. One vsyscall can reserve more than 1 slot to avoid
13  *  jumping out of line if necessary.
14  *
15  *  $Id: vsyscall.c,v 1.4 2001/09/27 17:58:13 ak Exp $
16  */
17
18 /*
19  * TODO 2001-03-20:
20  *
21  * 1) make page fault handler detect faults on page1-page-last of the vsyscall
22  *    virtual space, and make it increase %rip and write -ENOSYS in %rax (so
23  *    we'll be able to upgrade to a new glibc without upgrading kernel after
24  *    we add more vsyscalls.
25  * 2) Possibly we need a fixmap table for the vsyscalls too if we want
26  *    to avoid SIGSEGV and we want to return -EFAULT from the vsyscalls as well.
27  *    Can we segfault inside a "syscall"? We can fix this anytime and those fixes
28  *    won't be visible for userspace. Not fixing this is a noop for correct programs,
29  *    broken programs will segfault and there's no security risk until we choose to
30  *    fix it.
31  *
32  * These are not urgent things that we need to address only before shipping the first
33  * production binary kernels.
34  */
35
36 #include <linux/time.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39 #include <linux/timer.h>
40
41 #include <asm/vsyscall.h>
42 #include <asm/pgtable.h>
43 #include <asm/page.h>
44 #include <asm/fixmap.h>
45 #include <asm/errno.h>
46
47 #define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr)))
48
49 static inline void timeval_normalize(struct timeval * tv)
50 {
51         time_t __sec;
52
53         __sec = tv->tv_usec / 1000000;
54         if (__sec)
55         {
56                 tv->tv_usec %= 1000000;
57                 tv->tv_sec += __sec;
58         }
59 }
60
61 long __vxtime_sequence[2] __section_vxtime_sequence;
62
63 /* The rest of the kernel knows it as this. */
64 extern void do_gettimeofday(struct timeval *tv) __attribute__((alias("do_vgettimeofday"))); 
65
66 inline void do_vgettimeofday(struct timeval * tv)
67 {
68         long sequence;
69         unsigned long usec, sec;
70
71         do {
72                 unsigned long eax, edx;
73
74                 sequence = __vxtime_sequence[1];
75                 rmb();
76                 
77                 /* Read the Time Stamp Counter */
78                 rdtsc(eax,edx);
79
80                 /* .. relative to previous jiffy (32 bits is enough) */
81                 eax -= __last_tsc_low;  /* tsc_low delta */
82
83                 /*
84                  * Time offset = (tsc_low delta) * fast_gettimeoffset_quotient
85                  *             = (tsc_low delta) * (usecs_per_clock)
86                  *             = (tsc_low delta) * (usecs_per_jiffy / clocks_per_jiffy)
87                  *
88                  * Using a mull instead of a divl saves up to 31 clock cycles
89                  * in the critical path.
90                  */
91
92                 edx = (eax*__fast_gettimeoffset_quotient) >> 32;
93
94                 /* our adjusted time offset in microseconds */
95                 usec = __delay_at_last_interrupt + edx;
96
97                 {
98                         unsigned long lost = __jiffies - __wall_jiffies;
99                         if (lost)
100                                 usec += lost * (1000000 / HZ);
101                 }
102                 sec = __xtime.tv_sec;
103                 usec += __xtime.tv_usec;
104
105                 rmb();
106         } while (sequence != __vxtime_sequence[0]);
107
108         tv->tv_sec = sec;
109         tv->tv_usec = usec;
110         timeval_normalize(tv);
111 }
112
113 static inline void do_get_tz(struct timezone * tz)
114 {
115         long sequence;
116
117         do {
118                 sequence = __vxtime_sequence[1];
119                 rmb();
120
121                 *tz = __sys_tz;
122
123                 rmb();
124         } while (sequence != __vxtime_sequence[0]);
125 }
126
127 static int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz)
128 {
129         if (tv)
130                 do_vgettimeofday(tv);
131         if (tz)
132                 do_get_tz(tz);
133         return 0;
134 }
135
136 static time_t __vsyscall(1) vtime(time_t * time)
137 {
138         long sequence;
139         time_t __time;
140
141         do {
142                 sequence = __vxtime_sequence[1];
143                 rmb();
144
145                 __time = __xtime.tv_sec;
146
147                 rmb();
148         } while (sequence != __vxtime_sequence[0]);
149
150         if (time)
151                 *time = __time;
152         return __time;
153 }
154
155 static long __vsyscall(2) venosys_0(void)
156 {
157         return -ENOSYS;
158 }
159
160 static long __vsyscall(3) venosys_1(void)
161 {
162         return -ENOSYS;
163 }
164
165 static void __init map_vsyscall(void)
166 {
167         extern char __vsyscall_0;
168         unsigned long physaddr_page0 = (unsigned long) &__vsyscall_0 - __START_KERNEL_map;
169
170         __set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
171 }
172
173 static int __init vsyscall_init(void)
174 {
175         printk("VSYSCALL: consistency checks...");
176         if ((unsigned long) &vgettimeofday != VSYSCALL_ADDR(__NR_vgettimeofday))
177                 panic("vgettimeofday link addr broken");
178         if ((unsigned long) &vtime != VSYSCALL_ADDR(__NR_vtime))
179                 panic("vtime link addr broken");
180         if (VSYSCALL_ADDR(0) != __fix_to_virt(VSYSCALL_FIRST_PAGE))
181                 panic("fixmap first vsyscall %lx should be %lx", __fix_to_virt(VSYSCALL_FIRST_PAGE),
182                       VSYSCALL_ADDR(0));
183         printk("passed...mapping...");
184         map_vsyscall();
185         printk("done.\n");
186
187         return 0;
188 }
189
190 __initcall(vsyscall_init);