[common/c-host] move agnostic code into common library

common/CMakeLists.txt

@@ -9,6 +9,8 @@ if(ENABLE_BACKTRACE)
   add_definitions(-DENABLE_BACKTRACE)
 endif()
 
+add_subdirectory(src/platform)
+
 set(COMMON_SOURCES
   src/stringutils.c
   src/stringlist.c
@@ -16,26 +18,8 @@ set(COMMON_SOURCES
   src/framebuffer.c
 )
 
-set(LINUX_SOURCES
-  src/crash.linux.c
-  src/sysinfo.linux.c
-)
-
-set(WINDOWS_SOURCES
-  src/crash.windows.c
-  src/sysinfo.windows.c
-)
-
-if(WIN32)
-  set(SOURCES ${COMMON_SOURCES} ${WINDOWS_SOURCES})
-  add_library(lg_common STATIC ${SOURCES})
-else()
-  set(SOURCES ${COMMON_SOURCES} ${LINUX_SOURCES})
-  add_library(lg_common STATIC ${SOURCES})
-  if(ENABLE_BACKTRACE)
-    target_link_libraries(lg_common bfd)
-  endif()
-endif()
+add_library(lg_common STATIC ${COMMON_SOURCES})
+target_link_libraries(lg_common lg_common_platform)
 
 target_include_directories(lg_common
 	INTERFACE

common/include/common/event.h

@@ -0,0 +1,37 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#pragma once
+
+#include <stdbool.h>
+
+#define TIMEOUT_INFINITE ((unsigned int)~0)
+
+typedef struct LGEvent LGEvent;
+
+LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime);
+void      lgFreeEvent  (LGEvent * handle);
+bool      lgWaitEvent  (LGEvent * handle, unsigned int timeout);
+bool      lgWaitEvents (LGEvent * handles[], int count, bool waitAll, unsigned int timeout);
+bool      lgSignalEvent(LGEvent * handle);
+bool      lgResetEvent (LGEvent * handle);
+
+// os specific method to wrap/convert a native event into a LGEvent
+// for windows this is an event HANDLE
+LGEvent * lgWrapEvent(void * handle);

common/include/common/locking.h

@@ -18,7 +18,6 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #pragma once
 
-#if defined(__GCC__) || defined(__GNUC__)
 #define INTERLOCKED_AND8        __sync_fetch_and_and
 #define INTERLOCKED_OR8         __sync_fetch_and_or
 #define INTERLOCKED_INC(x)      __sync_fetch_and_add((x), 1)
@@ -30,12 +29,3 @@ Place, Suite 330, Boston, MA 02111-1307 USA
   while(__sync_lock_test_and_set(&(lock), 1)) while((lock)); \
   x\
   __sync_lock_release(&(lock));
-
-#else
-#define INTERLOCKED_OR8         InterlockedOr8
-#define INTERLOCKED_AND8        InterlockedAnd8
-#define INTERLOCKED_INC         InterlockedIncrement
-#define INTERLOCKED_DEC         InterlockedDecrement
-#define INTERLOCKED_GET(x)      InterlockedAdd((x), 0)
-#define INTERLOCKED_CE(x, c, v) InterlockedCompareExchange((x), (v), (c))
-#endif

common/include/common/thread.h

@@ -0,0 +1,28 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#pragma once
+
+#include <stdbool.h>
+
+typedef struct LGThread LGThread;
+typedef int (*LGThreadFunction)(void * opaque);
+
+bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle);
+bool lgJoinThread  (LGThread * handle, int * resultCode);

common/include/common/time.h

@@ -0,0 +1,45 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#pragma once
+
+#include <stdint.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <time.h>
+#endif
+
+static inline uint64_t getMicrotime()
+{
+#if defined(_WIN32)
+  static LARGE_INTEGER freq = { 0 };
+  if (!freq.QuadPart)
+    QueryPerformanceFrequency(&freq);
+
+  LARGE_INTEGER time;
+  QueryPerformanceCounter(&time);
+  return time.QuadPart / (freq.QuadPart / 1000000LL);
+#else
+  struct timespec time;
+  clock_gettime(CLOCK_MONOTONIC, &time);
+  return (uint64_t)time.tv_sec * 1000000LL + time.tv_nsec / 1000LL;
+#endif
+}

common/include/common/windebug.h

@@ -0,0 +1,35 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#pragma once
+
+#include "debug.h"
+#include <windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void DebugWinError(const char * file, const unsigned int line, const char * function, const char * desc, HRESULT status);
+
+#define DEBUG_WINERROR(x, y) DebugWinError(STRIPPATH(__FILE__), __LINE__, __FUNCTION__, x, y)
+
+#ifdef __cplusplus
+}
+#endif

common/src/platform/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform LANGUAGES C)
+
+if (UNIX)
+  add_subdirectory("linux")
+elseif(WIN32)
+  add_subdirectory("windows")
+endif()
+
+add_library(lg_common_platform INTERFACE)
+target_link_libraries(lg_common_platform INTERFACE lg_common_platform_code)

common/src/platform/linux/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform_code LANGUAGES C)
+
+include_directories(
+	${PROJECT_SOURCE_DIR}/include
+)
+
+add_library(lg_common_platform_code STATIC
+    crash.c
+    sysinfo.c
+)

common/src/platform/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform_code LANGUAGES C)
+
+include_directories(
+	${PROJECT_SOURCE_DIR}/include
+)
+
+add_library(lg_common_platform_code STATIC
+    crash.c
+    sysinfo.c
+    thread.c
+    event.c
+    windebug.c
+)

common/src/platform/windows/event.c

@@ -0,0 +1,221 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "common/event.h"
+#include "common/windebug.h"
+#include "common/time.h"
+
+#include <windows.h>
+
+struct LGEvent
+{
+  volatile int  lock;
+  bool          reset;
+  HANDLE        handle;
+  bool          wrapped;
+  unsigned int  msSpinTime;
+  volatile bool signaled;
+};
+
+LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime)
+{
+  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
+  if (!event)
+  {
+    DEBUG_ERROR("out of ram");
+    return NULL;
+  }
+
+  event->lock       = 0;
+  event->reset      = autoReset;
+  event->handle     = CreateEvent(NULL, autoReset ? FALSE : TRUE, FALSE, NULL);
+  event->wrapped    = false;
+  event->msSpinTime = msSpinTime;
+  event->signaled   = false;
+
+  if (!event->handle)
+  {
+    DEBUG_WINERROR("Failed to create the event", GetLastError());
+    free(event);
+    return NULL;
+  }
+
+  return event;
+}
+
+LGEvent * lgWrapEvent(void * handle)
+{
+  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
+  if (!event)
+  {
+    DEBUG_ERROR("out of ram");
+    return NULL;
+  }
+
+  event->lock       = 0;
+  event->reset      = false;
+  event->handle     = (HANDLE)handle;
+  event->wrapped    = true;
+  event->msSpinTime = 0;
+  event->signaled   = false;
+  return event;
+}
+
+void lgFreeEvent(LGEvent * event)
+{
+  CloseHandle(event->handle);
+}
+
+bool lgWaitEvent(LGEvent * event, unsigned int timeout)
+{
+  // wrapped events can't be enahnced
+  if (!event->wrapped)
+  {
+    if (event->signaled)
+    {
+      if (event->reset)
+        event->signaled = false;
+      return true;
+    }
+
+    if (timeout == 0)
+    {
+      bool ret = event->signaled;
+      if (event->reset)
+        event->signaled = false;
+      return ret;
+    }
+
+    if (event->msSpinTime)
+    {
+      unsigned int spinTime = event->msSpinTime;
+      if (timeout != TIMEOUT_INFINITE)
+      {
+        if (timeout > event->msSpinTime)
+          timeout -= event->msSpinTime;
+        else
+        {
+          spinTime -= timeout;
+          timeout   = 0;
+        }
+      }
+
+      uint64_t now = getMicrotime();
+      uint64_t end = now + spinTime * 1000;
+      while(!event->signaled)
+      {
+        now = getMicrotime();
+        if (now >= end)
+          break;
+      }
+
+      if (event->signaled)
+      {
+        if (event->reset)
+          event->signaled = false;
+        return true;
+      }
+    }
+  }
+
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+  while(true)
+  {
+    switch(WaitForSingleObject(event->handle, to))
+    {
+      case WAIT_OBJECT_0:
+        if (!event->reset)
+          event->signaled = true;
+        return true;
+
+      case WAIT_ABANDONED:
+        continue;
+
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    return false;
+  }
+}
+
+bool lgWaitEvents(LGEvent * events[], int count, bool waitAll, unsigned int timeout)
+{
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+
+  HANDLE * handles = (HANDLE *)malloc(sizeof(HANDLE) * count);
+  for(int i = 0; i < count; ++i)
+    handles[i] = events[i]->handle;
+
+  while(true)
+  {
+    DWORD result = WaitForMultipleObjects(count, handles, waitAll, to);
+    if (result >= WAIT_OBJECT_0 && result < count)
+    {
+      // null non signaled events from the handle list
+      for(int i = 0; i < count; ++i)
+        if (i != result && !lgWaitEvent(events[i], 0))
+          handles[i] = NULL;
+      free(handles);
+      return true;
+    }
+
+    if (result >= WAIT_ABANDONED_0 && result - WAIT_ABANDONED_0 < count)
+      continue;
+
+    switch(result)
+    {
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        free(handles);
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        free(handles);
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    free(handles);
+    return false;
+  }
+}
+
+bool lgSignalEvent(LGEvent * event)
+{
+  event->signaled = true;
+  return SetEvent(event->handle);
+}
+
+bool lgResetEvent(LGEvent * event)
+{
+  event->signaled = false;
+  return ResetEvent(event->handle);
+}

common/src/platform/windows/thread.c

@@ -0,0 +1,93 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "common/thread.h"
+#include "common/debug.h"
+#include "common/windebug.h"
+
+#include <windows.h>
+
+struct LGThread
+{
+  const char       * name;
+  LGThreadFunction   function;
+  void             * opaque;
+  HANDLE             handle;
+  DWORD              threadID;
+
+  int                resultCode;
+};
+
+static DWORD WINAPI threadWrapper(LPVOID lpParameter)
+{
+  LGThread * handle = (LGThread *)lpParameter;
+  handle->resultCode = handle->function(handle->opaque);
+  return 0;
+}
+
+bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle)
+{
+  *handle             = (LGThread *)malloc(sizeof(LGThread));
+  (*handle)->name     = name;
+  (*handle)->function = function;
+  (*handle)->opaque   = opaque;
+  (*handle)->handle   = CreateThread(NULL, 0, threadWrapper, *handle, 0, &(*handle)->threadID);
+
+  if (!(*handle)->handle)
+  {
+    free(*handle);
+    *handle = NULL;
+    DEBUG_WINERROR("CreateThread failed", GetLastError());
+    return false;
+  }
+
+  return true;
+}
+
+bool lgJoinThread(LGThread * handle, int * resultCode)
+{
+  while(true)
+  {
+    switch(WaitForSingleObject(handle->handle, INFINITE))
+    {
+      case WAIT_OBJECT_0:
+        if (resultCode)
+          *resultCode = handle->resultCode;
+        CloseHandle(handle->handle);
+        free(handle);
+        return true;
+
+      case WAIT_ABANDONED:
+      case WAIT_TIMEOUT:
+        continue;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for thread failed", GetLastError());
+        CloseHandle(handle->handle);
+        free(handle);
+        return false;
+    }
+
+    break;
+  }
+
+  DEBUG_WINERROR("Unknown failure waiting for thread", GetLastError());
+  return false;
+}
+

common/src/platform/windows/windebug.c

@@ -0,0 +1,42 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "common/windebug.h"
+#include <stdio.h>
+
+void DebugWinError(const char * file, const unsigned int line, const char * function, const char * desc, HRESULT status)
+{
+  char *buffer;
+  FormatMessageA(
+    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+    NULL,
+    status,
+    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+    (char*)&buffer,
+    1024,
+    NULL
+  );
+
+  for(size_t i = strlen(buffer) - 1; i > 0; --i)
+    if (buffer[i] == '\n' || buffer[i] == '\r')
+      buffer[i] = 0;
+
+  fprintf(stderr, "[E] %20s:%-4u | %-30s | %s: 0x%08x (%s)\n", file, line, function, desc, (int)status, buffer);
+  LocalFree(buffer);
+}