glue-infoblock.c

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
// Contains implementations of syscalls that use global info blocks instead of
// native syscalls proper.
 
#include "pedigree/kernel/process/InfoBlock.h"
 
#include <config.h>
#include <errno.h>
#include <stdint.h>
#include <time.h>
 
#include <sys/select.h>
#include <sys/syscall.h>
 
#if X86_COMMON
static struct InfoBlock* infoBlock = (struct InfoBlock*)0xFFFFFFFF8FFF0000;
#elif HOSTED
static struct InfoBlock* infoBlock = (struct InfoBlock*)0x0000710000000000;
#else
#error no infoblock address configured for this platform
#endif
 
struct getcpu_cache;
 
int __vdso_clock_gettime(clockid_t clock_id, struct timespec* tp);
int __vdso_gettimeofday(struct timeval* tv, void* tz);
int __vdso_getcpu(unsigned* cpu, unsigned* node, struct getcpu_cache* cache);
time_t __vdso_time(time_t* tloc);
 
int __vdso_clock_gettime(clockid_t clock_id, struct timespec* tp) {
#if X64 && !HOSTED
  // A shared snapshot can be arbitrarily old without periodic interrupts.
  long result = SYS_clock_gettime;
  __asm__ volatile("syscall"
                   : "+a"(result)
                   : "D"(clock_id), "S"(tp)
                   : "rcx", "r11", "memory", "cc");
  return (int)result;
#else
  if (!tp) {
    return -EFAULT;
  }
 
  uint64_t now;
  if (clock_id == CLOCK_REALTIME) {
    now = infoBlock->now;
  } else if (clock_id == CLOCK_MONOTONIC || clock_id == CLOCK_MONOTONIC_RAW) {
    // InfoBlock publishes getTicks(), which is not frequency-adjusted.
    now = infoBlock->monotonic;
  } else {
    return -EINVAL;
  }
 
  const uint64_t seconds = now / 1000000000U;
  tp->tv_sec = seconds;
  tp->tv_nsec = now - seconds * 1000000000U;
 
  return 0;
#endif
}
 
int __vdso_gettimeofday(struct timeval* tv, void* tz) {
#if X64 && !HOSTED
  long result = SYS_gettimeofday;
  __asm__ volatile("syscall" : "+a"(result) : "D"(tv), "S"(tz) : "rcx", "r11", "memory", "cc");
  return (int)result;
#else
  if (tv) {
    // 'now' is in nanoseconds.
    uint64_t now = infoBlock->now;
    const uint64_t seconds = now / 1000000000U;
    tv->tv_sec = seconds;
    tv->tv_usec = (now - seconds * 1000000000U) / 1000U;
  }
 
 
  return 0;
#endif
}
 
int __vdso_getcpu(unsigned* cpu, unsigned* node, struct getcpu_cache* cache) {
#if X64
  if (infoBlock->vdso_features & INFO_BLOCK_VDSO_GETCPU_RDTSCP) {
    unsigned ignored_low, ignored_high, aux;
    __asm__ volatile("rdtscp" : "=a"(ignored_low), "=d"(ignored_high), "=c"(aux) : : "memory");
    if (cpu) {
      *cpu = aux;
    }
    if (node) {
      *node = 0;
    }
    return 0;
  }
 
  // The shared info block cannot identify the calling task's current CPU.
  long result = 309;
  __asm__ volatile("syscall"
                   : "+a"(result)
                   : "D"(cpu), "S"(node), "d"(cache)
                   : "rcx", "r11", "memory", "cc");
  return (int)result;
#else
  (void)cpu;
  (void)node;
  (void)cache;
  return -ENOSYS;
#endif
}
 
time_t __vdso_time(time_t* tloc) {
#if X64 && !HOSTED
  long result = SYS_time;
  __asm__ volatile("syscall" : "+a"(result) : "D"(tloc) : "rcx", "r11", "memory", "cc");
  return (time_t)result;
#else
  const time_t now = infoBlock->now_s;
  if (tloc) {
    *tloc = now;
  }
 
  return now;
#endif
}
 
__asm__(".symver __vdso_clock_gettime,__vdso_clock_gettime@LINUX_2.6");
__asm__(".symver __vdso_gettimeofday,__vdso_gettimeofday@LINUX_2.6");
__asm__(".symver __vdso_getcpu,__vdso_getcpu@LINUX_2.6");
__asm__(".symver __vdso_time,__vdso_time@LINUX_2.6");
 
int clock_gettime(clockid_t, struct timespec*) __attribute__((weak, alias("__vdso_clock_gettime")));
int gettimeofday(struct timeval* __restrict, void* __restrict)
    __attribute__((weak, alias("__vdso_gettimeofday")));
int getcpu(unsigned*, unsigned*, struct getcpu_cache*)
    __attribute__((weak, alias("__vdso_getcpu")));
time_t time(time_t*) __attribute__((weak, alias("__vdso_time")));