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 /* Assume __initcall executes before all user space. Hopefully kmod
 213    doesn't violate that. We'll find out if it does. */
 214 static void __cpuinit vsyscall_set_cpu(int cpu)
 215 {
 216         unsigned long d;
 217         unsigned long node = 0;
 218 #ifdef CONFIG_NUMA
 219         node = cpu_to_node(cpu);
 220 #endif
 221         if (cpu_has(&cpu_data(cpu), X86_FEATURE_RDTSCP))
 222                 write_rdtscp_aux((node << 12) | cpu);
 223
 224         /* Store cpu number in limit so that it can be loaded quickly
 225            in user space in vgetcpu.
 226            12 bits for the CPU and 8 bits for the node. */
 227         d = 0x0f40000000000ULL;
 228         d |= cpu;
 229         d |= (node & 0xf) << 12;
 230         d |= (node >> 4) << 48;
 231         write_gdt_entry(get_cpu_gdt_table(cpu), GDT_ENTRY_PER_CPU, &d, DESCTYPE_S);
 232 }
 233
 234 static void __cpuinit cpu_vsyscall_init(void *arg)
 235 {
 236         /* preemption should be already off */
 237         vsyscall_set_cpu(raw_smp_processor_id());
 238 }
 239
 240 static int __cpuinit
 241 cpu_vsyscall_notifier(struct notifier_block *n, unsigned long action, void *arg)
 242 {
 243         long cpu = (long)arg;
 244         if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN)
 245                 smp_call_function_single(cpu, cpu_vsyscall_init, NULL, 1);
 246         return NOTIFY_DONE;
 247 }
 248
 249 void __init map_vsyscall(void)
 250 {
 251         extern char __vsyscall_0;
 252         unsigned long physaddr_page0 = __pa_symbol(&__vsyscall_0);
 253         extern char __vvar_page;
 254         unsigned long physaddr_vvar_page = __pa_symbol(&__vvar_page);
 255
 256         /* Note that VSYSCALL_MAPPED_PAGES must agree with the code below. */
 257         __set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
 258         __set_fixmap(VVAR_PAGE, physaddr_vvar_page, PAGE_KERNEL_VVAR);
 259         BUILD_BUG_ON((unsigned long)__fix_to_virt(VVAR_PAGE) !=
 260                      (unsigned long)VVAR_ADDRESS);
 261 }
 262
 263 static int __init vsyscall_init(void)
 264 {
 265         BUG_ON(((unsigned long) &vgettimeofday !=
 266                         VSYSCALL_ADDR(__NR_vgettimeofday)));
 267         BUG_ON((unsigned long) &vtime != VSYSCALL_ADDR(__NR_vtime));
 268         BUG_ON((VSYSCALL_ADDR(0) != __fix_to_virt(VSYSCALL_FIRST_PAGE)));
 269         BUG_ON((unsigned long) &vgetcpu != VSYSCALL_ADDR(__NR_vgetcpu));
 270         on_each_cpu(cpu_vsyscall_init, NULL, 1);
 271         /* notifier priority > KVM */
 272         hotcpu_notifier(cpu_vsyscall_notifier, 30);
 273         return 0;
 274 }
 275
 276 __initcall(vsyscall_init);