arch/x86/kernel/vsyscall_64.c

   1 /*
   2  *  Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
   3  *  Copyright 2003 Andi Kleen, SuSE Labs.
   4  *
   5  *  Thanks to hpa@transmeta.com for some useful hint.
   6  *  Special thanks to Ingo Molnar for his early experience with
   7  *  a different vsyscall implementation for Linux/IA32 and for the name.
   8  *
   9  *  vsyscall 1 is located at -10Mbyte, vsyscall 2 is located
  10  *  at virtual address -10Mbyte+1024bytes etc... There are at max 4
  11  *  vsyscalls. One vsyscall can reserve more than 1 slot to avoid
  12  *  jumping out of line if necessary. We cannot add more with this
  13  *  mechanism because older kernels won't return -ENOSYS.
  14  *  If we want more than four we need a vDSO.
  15  *
  16  *  Note: the concept clashes with user mode linux. If you use UML and
  17  *  want per guest time just set the kernel.vsyscall64 sysctl to 0.
  18  */
  19
  20 /* Disable profiling for userspace code: */
  21 #define DISABLE_BRANCH_PROFILING
  22
  23 #include <linux/time.h>
  24 #include <linux/init.h>
  25 #include <linux/kernel.h>
  26 #include <linux/timer.h>
  27 #include <linux/seqlock.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/sysctl.h>
  30 #include <linux/clocksource.h>
  31 #include <linux/getcpu.h>
  32 #include <linux/cpu.h>
  33 #include <linux/smp.h>
  34 #include <linux/notifier.h>
  35
  36 #include <asm/vsyscall.h>
  37 #include <asm/pgtable.h>
  38 #include <asm/page.h>
  39 #include <asm/unistd.h>
  40 #include <asm/fixmap.h>
  41 #include <asm/errno.h>
  42 #include <asm/io.h>
  43 #include <asm/segment.h>
  44 #include <asm/desc.h>
  45 #include <asm/topology.h>
  46 #include <asm/vgtod.h>
  47
  48 #define __vsyscall(nr) \
  49                 __attribute__ ((unused, __section__(".vsyscall_" #nr))) notrace
  50 #define __syscall_clobber "r11","cx","memory"
  51
  52 DEFINE_VVAR(int, vgetcpu_mode);
  53 DEFINE_VVAR(struct vsyscall_gtod_data, vsyscall_gtod_data) =
  54 {
  55         .lock = __SEQLOCK_UNLOCKED(__vsyscall_gtod_data.lock),
  56 };
  57
  58 void update_vsyscall_tz(void)
  59 {
  60         unsigned long flags;
  61
  62         write_seqlock_irqsave(&vsyscall_gtod_data.lock, flags);
  63         /* sys_tz has changed */
  64         vsyscall_gtod_data.sys_tz = sys_tz;
  65         write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags);
  66 }
  67
  68 void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
  69                         struct clocksource *clock, u32 mult)
  70 {
  71         unsigned long flags;
  72
  73         write_seqlock_irqsave(&vsyscall_gtod_data.lock, flags);
  74         /* copy vsyscall data */
  75         vsyscall_gtod_data.clock.vread = clock->vread;
  76         vsyscall_gtod_data.clock.cycle_last = clock->cycle_last;
  77         vsyscall_gtod_data.clock.mask = clock->mask;
  78         vsyscall_gtod_data.clock.mult = mult;
  79         vsyscall_gtod_data.clock.shift = clock->shift;
  80         vsyscall_gtod_data.wall_time_sec = wall_time->tv_sec;
  81         vsyscall_gtod_data.wall_time_nsec = wall_time->tv_nsec;
  82         vsyscall_gtod_data.wall_to_monotonic = *wtm;
  83         vsyscall_gtod_data.wall_time_coarse = __current_kernel_time();
  84         write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags);
  85 }
  86
  87 /* RED-PEN may want to readd seq locking, but then the variable should be
  88  * write-once.
  89  */
  90 static __always_inline void do_get_tz(struct timezone * tz)
  91 {
  92         *tz = VVAR(vsyscall_gtod_data).sys_tz;
  93 }
  94
  95 static __always_inline int gettimeofday(struct timeval *tv, struct timezone *tz)
  96 {
  97         int ret;
  98         asm volatile("syscall"
  99                 : "=a" (ret)
 100                 : "0" (__NR_gettimeofday),"D" (tv),"S" (tz)
 101                 : __syscall_clobber );
 102         return ret;
 103 }
 104
 105 static __always_inline void do_vgettimeofday(struct timeval * tv)
 106 {
 107         cycle_t now, base, mask, cycle_delta;
 108         unsigned seq;
 109         unsigned long mult, shift, nsec;
 110         cycle_t (*vread)(void);
 111         do {
 112                 seq = read_seqbegin(&VVAR(vsyscall_gtod_data).lock);
 113
 114                 vread = VVAR(vsyscall_gtod_data).clock.vread;
 115                 if (unlikely(!vread)) {
 116                         gettimeofday(tv,NULL);
 117                         return;
 118                 }
 119
 120                 now = vread();
 121                 base = VVAR(vsyscall_gtod_data).clock.cycle_last;
 122                 mask = VVAR(vsyscall_gtod_data).clock.mask;
 123                 mult = VVAR(vsyscall_gtod_data).clock.mult;
 124                 shift = VVAR(vsyscall_gtod_data).clock.shift;
 125
 126                 tv->tv_sec = VVAR(vsyscall_gtod_data).wall_time_sec;
 127                 nsec = VVAR(vsyscall_gtod_data).wall_time_nsec;
 128         } while (read_seqretry(&VVAR(vsyscall_gtod_data).lock, seq));
 129
 130         /* calculate interval: */
 131         cycle_delta = (now - base) & mask;
 132         /* convert to nsecs: */
 133         nsec += (cycle_delta * mult) >> shift;
 134
 135         while (nsec >= NSEC_PER_SEC) {
 136                 tv->tv_sec += 1;
 137                 nsec -= NSEC_PER_SEC;
 138         }
 139         tv->tv_usec = nsec / NSEC_PER_USEC;
 140 }
 141
 142 int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz)
 143 {
 144         if (tv)
 145                 do_vgettimeofday(tv);
 146         if (tz)
 147                 do_get_tz(tz);
 148         return 0;
 149 }
 150
 151 /* This will break when the xtime seconds get inaccurate, but that is
 152  * unlikely */
 153 time_t __vsyscall(1) vtime(time_t *t)
 154 {
 155         unsigned seq;
 156         time_t result;
 157
 158         do {
 159                 seq = read_seqbegin(&VVAR(vsyscall_gtod_data).lock);
 160
 161                 result = VVAR(vsyscall_gtod_data).wall_time_sec;
 162
 163         } while (read_seqretry(&VVAR(vsyscall_gtod_data).lock, seq));
 164
 165         if (t)
 166                 *t = result;
 167         return result;
 168 }
 169
 170 /* Fast way to get current CPU and node.
 171    This helps to do per node and per CPU caches in user space.
 172    The result is not guaranteed without CPU affinity, but usually
 173    works out because the scheduler tries to keep a thread on the same
 174    CPU.
 175
 176    tcache must point to a two element sized long array.
 177    All arguments can be NULL. */
 178 long __vsyscall(2)
 179 vgetcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *tcache)
 180 {
 181         unsigned int p;
 182         unsigned long j = 0;
 183
 184         /* Fast cache - only recompute value once per jiffies and avoid
 185            relatively costly rdtscp/cpuid otherwise.
 186            This works because the scheduler usually keeps the process
 187            on the same CPU and this syscall doesn't guarantee its
 188            results anyways.
 189            We do this here because otherwise user space would do it on
 190            its own in a likely inferior way (no access to jiffies).
 191            If you don't like it pass NULL. */
 192         if (tcache && tcache->blob[0] == (j = VVAR(jiffies))) {
 193                 p = tcache->blob[1];
 194         } else if (VVAR(vgetcpu_mode) == VGETCPU_RDTSCP) {
 195                 /* Load per CPU data from RDTSCP */
 196                 native_read_tscp(&p);
 197         } else {
 198                 /* Load per CPU data from GDT */
 199                 asm("lsl %1,%0" : "=r" (p) : "r" (__PER_CPU_SEG));
 200         }
 201         if (tcache) {
 202                 tcache->blob[0] = j;
 203                 tcache->blob[1] = p;
 204         }
 205         if (cpu)
 206                 *cpu = p & 0xfff;
 207         if (node)
 208                 *node = p >> 12;
 209         return 0;
 210 }
 211
 212 static long __vsyscall(3) venosys_1(void)
 213 {
 214         return -ENOSYS;
 215 }
 216
 217 /* Assume __initcall executes before all user space. Hopefully kmod
 218    doesn't violate that. We'll find out if it does. */
 219 static void __cpuinit vsyscall_set_cpu(int cpu)
 220 {
 221         unsigned long d;
 222         unsigned long node = 0;
 223 #ifdef CONFIG_NUMA
 224         node = cpu_to_node(cpu);
 225 #endif
 226         if (cpu_has(&cpu_data(cpu), X86_FEATURE_RDTSCP))
 227                 write_rdtscp_aux((node << 12) | cpu);
 228
 229         /* Store cpu number in limit so that it can be loaded quickly
 230            in user space in vgetcpu.
 231            12 bits for the CPU and 8 bits for the node. */
 232         d = 0x0f40000000000ULL;
 233         d |= cpu;
 234         d |= (node & 0xf) << 12;
 235         d |= (node >> 4) << 48;
 236         write_gdt_entry(get_cpu_gdt_table(cpu), GDT_ENTRY_PER_CPU, &d, DESCTYPE_S);
 237 }
 238
 239 static void __cpuinit cpu_vsyscall_init(void *arg)
 240 {
 241         /* preemption should be already off */
 242         vsyscall_set_cpu(raw_smp_processor_id());
 243 }
 244
 245 static int __cpuinit
 246 cpu_vsyscall_notifier(struct notifier_block *n, unsigned long action, void *arg)
 247 {
 248         long cpu = (long)arg;
 249         if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN)
 250                 smp_call_function_single(cpu, cpu_vsyscall_init, NULL, 1);
 251         return NOTIFY_DONE;
 252 }
 253
 254 void __init map_vsyscall(void)
 255 {
 256         extern char __vsyscall_0;
 257         unsigned long physaddr_page0 = __pa_symbol(&__vsyscall_0);
 258         extern char __vvar_page;
 259         unsigned long physaddr_vvar_page = __pa_symbol(&__vvar_page);
 260
 261         /* Note that VSYSCALL_MAPPED_PAGES must agree with the code below. */
 262         __set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
 263         __set_fixmap(VVAR_PAGE, physaddr_vvar_page, PAGE_KERNEL_VVAR);
 264         BUILD_BUG_ON((unsigned long)__fix_to_virt(VVAR_PAGE) !=
 265                      (unsigned long)VVAR_ADDRESS);
 266 }
 267
 268 static int __init vsyscall_init(void)
 269 {
 270         BUG_ON(((unsigned long) &vgettimeofday !=
 271                         VSYSCALL_ADDR(__NR_vgettimeofday)));
 272         BUG_ON((unsigned long) &vtime != VSYSCALL_ADDR(__NR_vtime));
 273         BUG_ON((VSYSCALL_ADDR(0) != __fix_to_virt(VSYSCALL_FIRST_PAGE)));
 274         BUG_ON((unsigned long) &vgetcpu != VSYSCALL_ADDR(__NR_vgetcpu));
 275         on_each_cpu(cpu_vsyscall_init, NULL, 1);
 276         /* notifier priority > KVM */
 277         hotcpu_notifier(cpu_vsyscall_notifier, 30);
 278         return 0;
 279 }
 280
 281 __initcall(vsyscall_init);