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  *  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
  68                 if (__vxtime.mode == VXTIME_TSC) {
  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
 110 static int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz)
 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 */
 123 static time_t __vsyscall(1) vtime(time_t *t)
 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
 132 static long __vsyscall(2) venosys_0(void)
 133 {
 134         return -ENOSYS;
 135 }
 136
 137 static long __vsyscall(3) venosys_1(void)
 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();
 220         sysctl_vsyscall = 1;
 221         register_sysctl_table(kernel_root_table2, 0);
 222         return 0;
 223 }
 224
 225 __initcall(vsyscall_init);