DirectHW.c

/*
 * DirectHW.c - userspace part for DirectHW
 *
 * Copyright © 2008-2017 coresystems GmbH <info@coresystems.de>
 *
 * Permission to use, copy, modify, and/or 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.
 */

#include <AvailabilityMacros.h>
#include <IOKit/IOKitLib.h>
#include <ApplicationServices/ApplicationServices.h>
#include <CoreFoundation/CoreFoundation.h>
#include <unistd.h>
#include <inttypes.h>
#include <errno.h>
#include "DirectHW.h"

#ifndef MAP_FAILED
#define MAP_FAILED	((void *)-1)
#endif

/* define WANT_OLD_API for support of OSX 10.4 and earlier */
#undef WANT_OLD_API

/* define DEBUG to print Framework debugging information */
#undef DEBUG

#define     err_get_system(err) (((err)>>26)&0x3f)
#define     err_get_sub(err)    (((err)>>14)&0xfff)
#define     err_get_code(err)   ((err)&0x3fff)

enum {
  kReadIO,
  kWriteIO,
  kPrepareMap,
  kReadMSR,
  kReadCpuID,
  kReadMem,
  kWriteMSR,
  kNumberOfMethods
};

typedef struct {
  UInt32 offset;
  UInt32 width;
  UInt32 data;
} iomem_t;

typedef struct {
  UInt64 addr;
  UInt64 size;
} map_t;

typedef struct {
  UInt32 core;
  UInt32 index;
  UInt32 hi;
  UInt32 lo;
} msrcmd_t;

typedef struct {
  uint32_t core;
  uint32_t eax;
  uint32_t ecx;
  uint32_t cpudata[4];
} cpuid_t;

typedef struct {
  uint32_t core;
  uint64_t addr;
  uint32_t data;
} readmem_t;

static io_connect_t connect = -1;
static io_service_t iokit_uc;

static int darwin_init(void)
{
  kern_return_t err;

  /* Note the actual security happens in the kernel module.
   * This check is just candy to be able to get nicer output
   */
  if (getuid() != 0) {
    /* Fun's reserved for root */
    errno = EPERM;
    return -1;
  }

  /* Get the DirectHW driver service */
  iokit_uc = IOServiceGetMatchingService(kIOMasterPortDefault,
                                         IOServiceMatching("DirectHWService"));

  if (!iokit_uc) {
    printf("DirectHW.kext not loaded.\n");
    errno = ENOSYS;
    return -1;
  }

  /* Create an instance */
  err = IOServiceOpen(iokit_uc, mach_task_self(), 0, &connect);

  /* Should not go further if error with service open */
  if (err != KERN_SUCCESS) {
    printf("Could not create DirectHW instance.\n");
    errno = ENOSYS;
    return -1;
  }

  return 0;
}

static void darwin_cleanup(void)
{
  IOServiceClose(connect);
}

int darwin_ioread(int pos, unsigned char * buf, int len)
{

  kern_return_t err;
  size_t dataInLen = sizeof(iomem_t);
  size_t dataOutLen = sizeof(iomem_t);
  iomem_t in;
  iomem_t out;
  UInt32 tmpdata;

  in.width = len;
  in.offset = pos;

  if (len > 4)
    return 1;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kReadIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kReadIO, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS)
    return 1;

  tmpdata = out.data;

  switch (len) {
    case 1:
      memcpy(buf, &tmpdata, 1);
      break;
    case 2:
      memcpy(buf, &tmpdata, 2);
      break;
    case 4:
      memcpy(buf, &tmpdata, 4);
      break;
  }

  return 0;
}

static int darwin_iowrite(int pos, unsigned char * buf, int len)
{
  kern_return_t err;
  size_t dataInLen = sizeof(iomem_t);
  size_t dataOutLen = sizeof(iomem_t);
  iomem_t in;
  iomem_t out;

  in.width = len;
  in.offset = pos;
  memcpy(&in.data, buf, len);

  if (len > 4)
    return 1;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kWriteIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kWriteIO, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS)
    return 1;

  return 0;
}


/* Compatibility interface */

unsigned char inb(unsigned short addr)
{
  unsigned char ret;
  darwin_ioread(addr, &ret, 1);
  return ret;
}

unsigned short inw(unsigned short addr)
{
  unsigned short ret;
  darwin_ioread(addr, (unsigned char *)&ret, 2);
  return ret;
}

unsigned int inl(unsigned short addr)
{
  unsigned int ret;
  darwin_ioread(addr, (unsigned char *)&ret, 4);
  return ret;
}

void outb(unsigned char val, unsigned short addr)
{
  darwin_iowrite(addr, &val, 1);
}

void outw(unsigned short val, unsigned short addr)
{
  darwin_iowrite(addr, (unsigned char *)&val, 2);
}

void outl(unsigned int val, unsigned short addr)
{
  darwin_iowrite(addr, (unsigned char *)&val, 4);
}

int iopl(int level __attribute__((unused)))
{
  atexit(darwin_cleanup);
  return darwin_init();
}

void *map_physical(uint64_t phys_addr, size_t len)
{
  kern_return_t err;
#if __LP64__
  mach_vm_address_t addr;
  mach_vm_size_t size;
#else
  vm_address_t addr;
  vm_size_t size;
#endif
  size_t dataInLen = sizeof(map_t);
  size_t dataOutLen = sizeof(map_t);
  map_t in, out;

  in.addr = phys_addr;
  in.size = len;

#ifdef DEBUG
  printf("map_phys: phys %08lx, %08x\n", phys_addr, len);
#endif

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kPrepareMap, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kPrepareMap, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS) {
    printf("\nError(kPrepareMap): system 0x%x subsystem 0x%x code 0x%x ",
           err_get_system(err), err_get_sub(err), err_get_code(err));

    printf("physical 0x%"PRIx64"[0x%x]\n", phys_addr, (unsigned int)len);

    switch (err_get_code(err)) {
      case 0x2c2: printf("Invalid argument.\n"); errno = EINVAL; break;
      case 0x2cd: printf("Device not open.\n"); errno = ENOENT; break;
    }

    return MAP_FAILED;
  }

  err = IOConnectMapMemory(connect, 0, mach_task_self(),
                           &addr, &size, kIOMapAnywhere | kIOMapInhibitCache);

  /* Now this is odd; The above connect seems to be unfinished at the
   * time the function returns. So wait a little bit, or the calling
   * program will just segfault. Bummer. Who knows a better solution?
   */
  usleep(1000);

  if (err != KERN_SUCCESS) {
    printf("\nError(IOConnectMapMemory): system 0x%x subsystem 0x%x code 0x%x ",
           err_get_system(err), err_get_sub(err), err_get_code(err));

		printf("physical 0x%08llx[0x%x]\n", phys_addr, (unsigned int)len);

    switch (err_get_code(err)) {
      case 0x2c2: printf("Invalid argument.\n"); errno = EINVAL; break;
      case 0x2cd: printf("Device not open.\n"); errno = ENOENT; break;
    }

    return MAP_FAILED;
  }

#ifdef DEBUG
  printf("map_phys: virt %08x, %08x\n", addr, size);
#endif

  return (void *)addr;
}

void unmap_physical(void *virt_addr __attribute__((unused)), size_t len __attribute__((unused)))
{
  // Nut'n Honey
}

static int current_logical_cpu = 0;

msr_t rdmsr(int addr)
{
  kern_return_t err;
  size_t dataInLen = sizeof(msrcmd_t);
  size_t dataOutLen = sizeof(msrcmd_t);
  msrcmd_t in, out;
  msr_t ret = { INVALID_MSR_HI, INVALID_MSR_LO };

  in.core = current_logical_cpu;
  in.index = addr;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kReadMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kReadMSR, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS)
    return ret;

  ret.lo = out.lo;
  ret.hi = out.hi;

  return ret;
}

int rdcpuid(uint32_t eax, uint32_t ecx, uint32_t cpudata[4])
{
  kern_return_t err;
  size_t dataInLen = sizeof(cpuid_t);
  size_t dataOutLen = sizeof(cpuid_t);
  cpuid_t in, out;

  in.core = current_logical_cpu;
  in.eax = eax;
  in.ecx = ecx;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kReadCpuID, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kReadCpuID, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS)
    return -1;

  memcpy(cpudata, out.cpudata, sizeof(uint32_t) * 4);
  return 0;
}

int readmem32(uint64_t addr, uint32_t* data)
{
  kern_return_t err;
  size_t dataInLen = sizeof(readmem_t);
  size_t dataOutLen = sizeof(readmem_t);
  readmem_t in, out;

  in.core = current_logical_cpu;
  in.addr = addr;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kReadMem, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kReadMem, dataInLen, &dataOutLen, &in, &out);
}
#endif

if (err != KERN_SUCCESS)
    return -1;

  *data = out.data;
  return 0;
}

int wrmsr(int addr, msr_t msr)
{
  kern_return_t err;
  size_t dataInLen = sizeof(msrcmd_t);
  size_t dataOutLen = sizeof(msrcmd_t);
  msrcmd_t in, out;

  in.core = current_logical_cpu;
  in.index = addr;
  in.lo = msr.lo;
  in.hi = msr.hi;

#if !defined(__LP64__) && defined(WANT_OLD_API)
  /* Check if OSX 10.5 API is available */
  if (IOConnectCallStructMethod != NULL) {
#endif
    err = IOConnectCallStructMethod(connect, kWriteMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
  } else {
    /* Use old API */
    err = IOConnectMethodStructureIStructureO(connect, kWriteMSR, dataInLen, &dataOutLen, &in, &out);
  }
#endif

  if (err != KERN_SUCCESS)
    return 1;

  return 0;
}

int logical_cpu_select(int cpu)
{
  current_logical_cpu = cpu;
  return 0;
}