enclave 0.1.0

data/ext/enclave/mruby/mrbgems/hal-posix-socket/src/socket_hal.c

@@ -0,0 +1,158 @@
+/*
+** socket_hal.c - POSIX HAL implementation for mruby-socket
+**
+** See Copyright Notice in mruby.h
+**
+** POSIX implementation for socket operations using standard POSIX APIs.
+** Supported platforms: Linux, macOS, BSD, Unix
+*/
+
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/class.h>
+#include <mruby/error.h>
+#include <mruby/presym.h>
+#include "socket_hal.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * Socket HAL Initialization/Finalization
+ */
+
+void
+mrb_hal_socket_init(mrb_state *mrb)
+{
+  (void)mrb;
+  /* No initialization needed for POSIX sockets */
+}
+
+void
+mrb_hal_socket_final(mrb_state *mrb)
+{
+  (void)mrb;
+  /* No cleanup needed for POSIX sockets */
+}
+
+/*
+ * Socket Control Operations
+ */
+
+int
+mrb_hal_socket_set_nonblock(mrb_state *mrb, int fd, int nonblock)
+{
+  (void)mrb;
+
+  int flags = fcntl(fd, F_GETFL, 0);
+  if (flags == -1) {
+    return -1;
+  }
+
+  if (nonblock) {
+    flags |= O_NONBLOCK;
+  }
+  else {
+    flags &= ~O_NONBLOCK;
+  }
+
+  if (fcntl(fd, F_SETFL, flags) == -1) {
+    return -1;
+  }
+
+  return 0;
+}
+
+/*
+ * Address Conversion Functions
+ */
+
+const char*
+mrb_hal_socket_inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+  return inet_ntop(af, src, dst, (socklen_t)size);
+}
+
+int
+mrb_hal_socket_inet_pton(int af, const char *src, void *dst)
+{
+  return inet_pton(af, src, dst);
+}
+
+/*
+ * Platform-Specific Socket Features
+ */
+
+mrb_value
+mrb_hal_socket_sockaddr_un(mrb_state *mrb, const char *path, size_t pathlen)
+{
+  struct sockaddr_un *sunp;
+
+  if (pathlen > sizeof(sunp->sun_path) - 1) {
+    mrb_raisef(mrb, mrb_class_get_id(mrb, MRB_SYM(ArgumentError)),
+               "too long unix socket path (max: %d bytes)",
+               (int)sizeof(sunp->sun_path) - 1);
+  }
+
+  mrb_value s = mrb_str_new_capa(mrb, sizeof(struct sockaddr_un));
+  sunp = (struct sockaddr_un*)RSTRING_PTR(s);
+
+#if defined(HAVE_SA_LEN) && HAVE_SA_LEN
+  sunp->sun_len = sizeof(struct sockaddr_un);
+#endif
+
+  sunp->sun_family = AF_UNIX;
+  memcpy(sunp->sun_path, path, pathlen);
+  sunp->sun_path[pathlen] = '\0';
+  mrb_str_resize(mrb, s, sizeof(struct sockaddr_un));
+
+  return s;
+}
+
+int
+mrb_hal_socket_socketpair(mrb_state *mrb, int domain, int type, int protocol, int sv[2])
+{
+  (void)mrb;
+  return socketpair(domain, type, protocol, sv);
+}
+
+mrb_value
+mrb_hal_socket_unix_path(mrb_state *mrb, const char *sockaddr, size_t socklen)
+{
+  const struct sockaddr *sa = (const struct sockaddr*)sockaddr;
+
+  if (sa->sa_family != AF_UNIX) {
+    mrb_raise(mrb, mrb_class_get_id(mrb, MRB_SYM(SocketError)), "need AF_UNIX address");
+  }
+
+  if (socklen < offsetof(struct sockaddr_un, sun_path) + 1) {
+    return mrb_str_new(mrb, "", 0);
+  }
+
+  return mrb_str_new_cstr(mrb, ((const struct sockaddr_un*)sockaddr)->sun_path);
+}
+
+/*
+ * Gem initialization
+ */
+
+void
+mrb_hal_posix_socket_gem_init(mrb_state *mrb)
+{
+  (void)mrb;
+  /* HAL interface functions are called by mruby-socket gem */
+}
+
+void
+mrb_hal_posix_socket_gem_final(mrb_state *mrb)
+{
+  (void)mrb;
+  /* Cleanup handled by mrb_hal_socket_final called from mruby-socket */
+}

data/ext/enclave/mruby/mrbgems/hal-posix-task/README.md

@@ -0,0 +1,102 @@
+# hal-posix-task
+
+POSIX Hardware Abstraction Layer (HAL) implementation for mruby-task.
+
+## Description
+
+Provides timer and interrupt support for the mruby-task cooperative scheduler on POSIX-compliant platforms. Uses `SIGALRM` and `setitimer()` for periodic timer ticks, and `sigprocmask()` for interrupt protection.
+
+## Supported Platforms
+
+- Linux
+- macOS
+- BSD (FreeBSD, OpenBSD, NetBSD)
+- Other POSIX-compliant Unix systems
+
+## Requirements
+
+- POSIX-compliant operating system
+- Signal support (`SIGALRM`, `sigaction`, `sigprocmask`)
+- Timer support (`setitimer`, `ITIMER_REAL`)
+
+## Usage
+
+### Explicit HAL Selection (Recommended)
+
+```ruby
+MRuby::Build.new do |conf|
+  # ... other configuration ...
+
+  # Specify POSIX HAL - automatically brings in mruby-task
+  conf.gem core: 'hal-posix-task'
+end
+```
+
+### Auto-detection (Development)
+
+```ruby
+MRuby::Build.new do |conf|
+  # ... other configuration ...
+
+  # Auto-detects and selects hal-posix-task on POSIX platforms
+  conf.gem core: 'mruby-task'
+end
+```
+
+## Implementation Details
+
+### Timer Mechanism
+
+- Uses `setitimer(ITIMER_REAL, ...)` to generate periodic `SIGALRM` signals
+- Timer interval configured by `MRB_TICK_UNIT` (default: 4ms)
+- Signal handler calls `mrb_tick()` for all registered VM instances
+
+### Interrupt Protection
+
+- Critical sections protected using `sigprocmask()` to block `SIGALRM`
+- Prevents race conditions during task queue modifications
+- Supports nested critical sections through signal masking
+
+### Multi-VM Support
+
+- Supports up to `MRB_TASK_MAX_VMS` concurrent mruby VM instances (default: 8)
+- Single shared timer ticks all registered VMs
+- Per-VM task counters optimize timer usage (timer disabled when idle)
+
+### Timer Optimization
+
+The implementation dynamically enables/disables the timer based on task state:
+
+- **Timer enabled** when: Multiple ready tasks OR any waiting tasks exist
+- **Timer disabled** when: Single task or all tasks dormant/suspended
+- Reduces CPU usage and power consumption when scheduler is idle
+
+## Configuration
+
+Override these macros in your build config if needed:
+
+```ruby
+conf.gem core: 'hal-posix-task' do |spec|
+  # Custom tick interval (10ms instead of default 4ms)
+  spec.build.defines << 'MRB_TICK_UNIT=10'
+
+  # Custom timeslice (5 ticks instead of default 3)
+  spec.build.defines << 'MRB_TIMESLICE_TICK_COUNT=5'
+
+  # More concurrent VMs (16 instead of default 8)
+  spec.build.defines << 'MRB_TASK_MAX_VMS=16'
+end
+```
+
+## Known Limitations
+
+- `SIGALRM` conflicts with other code using the same signal
+- Timer resolution limited by platform (typically 1-10ms)
+- Signal delivery may be delayed under heavy system load
+- Not suitable for hard real-time requirements
+
+## See Also
+
+- `mruby-task` - Core task scheduler
+- `hal-win-task` - Windows HAL implementation
+- Task scheduler documentation: `mrbgems/mruby-task/README.md`

data/ext/enclave/mruby/mrbgems/hal-posix-task/mrbgem.rake

@@ -0,0 +1,8 @@
+MRuby::Gem::Specification.new('hal-posix-task') do |spec|
+  spec.license = 'MIT'
+  spec.authors = 'mruby developers'
+  spec.summary = 'POSIX HAL for mruby-task (Linux, macOS, BSD, Unix)'
+
+  # HAL gem depends on feature gem - brings in mruby-task automatically
+  spec.add_dependency 'mruby-task', core: 'mruby-task'
+end

data/ext/enclave/mruby/mrbgems/hal-posix-task/src/task_hal.c

@@ -0,0 +1,252 @@
+/*
+** task_hal.c - POSIX HAL implementation for mruby-task
+**
+** See Copyright Notice in mruby.h
+**
+** POSIX implementation using SIGALRM and setitimer() for timer,
+** and sigprocmask() for interrupt protection.
+**
+** Supported platforms: Linux, macOS, BSD, Unix
+**
+** Note: When compiled for Emscripten/WASM, the SIGALRM timer is disabled
+** because JavaScript handles tick calls via setInterval. Using both would
+** cause tick_ to increment twice as fast, making sleep wake up early.
+*/
+
+#include <mruby.h>
+#include "task_hal.h"
+#ifndef __EMSCRIPTEN__
+#include <signal.h>
+#include <sys/time.h>
+#endif
+#include <time.h>
+#include <unistd.h>
+#include <stdint.h>
+
+/* Time conversion constants */
+#define NSEC_PER_MSEC 1000000ULL
+#define NSEC_PER_SEC  1000000000ULL
+#define USEC_PER_MSEC 1000ULL
+
+#ifndef __EMSCRIPTEN__
+/* Multi-VM support */
+static mrb_state *vm_list[MRB_TASK_MAX_VMS];
+static volatile sig_atomic_t vm_count = 0;
+static sigset_t alarm_mask;
+
+/* SIGALRM signal handler - ticks all registered VMs */
+static void
+sigalrm_handler(int sig)
+{
+  int i;
+  (void)sig;
+  /* Tick all registered VMs */
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i]) {
+      mrb_tick(vm_list[i]);
+    }
+  }
+}
+#endif /* __EMSCRIPTEN__ */
+
+/*
+ * HAL Interface Implementation
+ */
+
+void
+mrb_hal_task_init(mrb_state *mrb)
+{
+  int i;
+
+  /* Initialize task state */
+  for (i = 0; i < 4; i++) {
+    mrb->task.queues[i] = NULL;
+  }
+  mrb->task.tick = 0;
+  mrb->task.wakeup_tick = UINT32_MAX;
+  mrb->task.switching = FALSE;
+
+#ifndef __EMSCRIPTEN__
+  /* POSIX: Set up SIGALRM timer for tick handling */
+  struct sigaction sa;
+  struct itimerval timer;
+  int vm_index = -1;
+
+  /* Block SIGALRM during registration to avoid race */
+  sigemptyset(&alarm_mask);
+  sigaddset(&alarm_mask, SIGALRM);
+  sigprocmask(SIG_BLOCK, &alarm_mask, NULL);
+
+  /* Check if this VM is already registered */
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i] == mrb) {
+      vm_index = i;
+      break;
+    }
+  }
+
+  /* Register new VM if not already present */
+  if (vm_index < 0) {
+    if (vm_count >= MRB_TASK_MAX_VMS) {
+      sigprocmask(SIG_UNBLOCK, &alarm_mask, NULL);
+      mrb_raisef(mrb, E_RUNTIME_ERROR,
+                 "too many mrb_states with task scheduler (max: %d)",
+                 MRB_TASK_MAX_VMS);
+    }
+    vm_list[vm_count] = mrb;
+    vm_count++;
+  }
+
+  /* Set up signal handler and timer only for first VM */
+  if (vm_count == 1) {
+    /* Set up signal handler - SA_RESTART to avoid breaking IO operations */
+    sa.sa_handler = sigalrm_handler;
+    sa.sa_flags = SA_RESTART;
+    sigemptyset(&sa.sa_mask);
+    sigaction(SIGALRM, &sa, NULL);
+
+    /* Start timer */
+    timer.it_value.tv_sec = 0;
+    timer.it_value.tv_usec = MRB_TICK_UNIT * 1000;
+    timer.it_interval.tv_sec = 0;
+    timer.it_interval.tv_usec = MRB_TICK_UNIT * 1000;
+    setitimer(ITIMER_REAL, &timer, NULL);
+  }
+
+  /* Unblock SIGALRM */
+  sigprocmask(SIG_UNBLOCK, &alarm_mask, NULL);
+#endif
+}
+
+void
+mrb_task_enable_irq(void)
+{
+#ifndef __EMSCRIPTEN__
+  sigprocmask(SIG_UNBLOCK, &alarm_mask, NULL);
+#endif
+}
+
+void
+mrb_task_disable_irq(void)
+{
+#ifndef __EMSCRIPTEN__
+  sigprocmask(SIG_BLOCK, &alarm_mask, NULL);
+#endif
+}
+
+void
+mrb_hal_task_idle_cpu(mrb_state *mrb)
+{
+  (void)mrb;
+  /* On POSIX, just pause briefly */
+  usleep(MRB_TICK_UNIT * 1000);
+}
+
+void
+mrb_hal_task_sleep_us(mrb_state *mrb, mrb_int usec)
+{
+  struct timespec start, now, sleep_time;
+  int ret;
+
+  (void)mrb;
+
+  /* Validate input to prevent overflow */
+  if (usec < 0) {
+    return;
+  }
+
+  ret = clock_gettime(CLOCK_MONOTONIC, &start);
+  if (ret != 0) {
+    /* Fallback to simple usleep if clock_gettime fails */
+    usleep(usec);
+    return;
+  }
+
+  uint64_t target_ns = (uint64_t)usec * USEC_PER_MSEC;
+
+  /* Loop until enough real time has elapsed */
+  while (1) {
+    ret = clock_gettime(CLOCK_MONOTONIC, &now);
+    if (ret != 0) {
+      break;  /* Clock failure - exit loop */
+    }
+
+    uint64_t elapsed_ns = (uint64_t)(now.tv_sec - start.tv_sec) * NSEC_PER_SEC +
+                          (uint64_t)(now.tv_nsec - start.tv_nsec);
+
+    if (elapsed_ns >= target_ns) {
+      break;
+    }
+
+    /* Sleep for remaining time, but at least 1ms to allow timer interrupts */
+    uint64_t remaining_ns = target_ns - elapsed_ns;
+    if (remaining_ns > NSEC_PER_MSEC) {
+      sleep_time.tv_sec = remaining_ns / NSEC_PER_SEC;
+      sleep_time.tv_nsec = remaining_ns % NSEC_PER_SEC;
+    }
+    else {
+      sleep_time.tv_sec = 0;
+      sleep_time.tv_nsec = NSEC_PER_MSEC;
+    }
+
+    nanosleep(&sleep_time, NULL);  /* Interrupted by signals - that's OK */
+  }
+}
+
+void
+mrb_hal_task_final(mrb_state *mrb)
+{
+#ifndef __EMSCRIPTEN__
+  struct itimerval timer;
+  int i, j;
+
+  /* Block SIGALRM during unregistration */
+  sigprocmask(SIG_BLOCK, &alarm_mask, NULL);
+
+  /* Find and remove this VM from the list */
+  for (i = 0; i < vm_count; i++) {
+    if (vm_list[i] == mrb) {
+      /* Shift remaining VMs down */
+      for (j = i; j < vm_count - 1; j++) {
+        vm_list[j] = vm_list[j + 1];
+      }
+      vm_list[vm_count - 1] = NULL;
+      vm_count--;
+      break;
+    }
+  }
+
+  /* Stop timer if last VM */
+  if (vm_count == 0) {
+    timer.it_value.tv_sec = 0;
+    timer.it_value.tv_usec = 0;
+    timer.it_interval.tv_sec = 0;
+    timer.it_interval.tv_usec = 0;
+    setitimer(ITIMER_REAL, &timer, NULL);
+  }
+
+  /* Unblock SIGALRM */
+  sigprocmask(SIG_UNBLOCK, &alarm_mask, NULL);
+#else
+  /* WASM: No timer cleanup needed */
+  (void)mrb;
+#endif
+}
+
+/*
+ * Gem initialization (empty - HAL functions called by mruby-task)
+ */
+
+void
+mrb_hal_posix_task_gem_init(mrb_state *mrb)
+{
+  (void)mrb;
+  /* HAL interface functions are called by mruby-task gem */
+}
+
+void
+mrb_hal_posix_task_gem_final(mrb_state *mrb)
+{
+  (void)mrb;
+  /* Cleanup handled by mrb_hal_task_final called from mruby-task */
+}

data/ext/enclave/mruby/mrbgems/hal-win-dir/mrbgem.rake

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('hal-win-dir') do |spec|
+  spec.license = 'MIT and MIT-like license'
+  spec.authors = ['mruby developers', 'Kevlin Henney']
+  spec.summary = 'Windows HAL for mruby-dir'
+
+  spec.add_dependency 'mruby-dir', core: 'mruby-dir'
+end