source_manager.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "serene/rt/source_manager.h"
 
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/fiber/io.h"
#include "serene/rt/impl/array_list.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/mm/interface.h"
#include "serene/utils.h"
 
srn_sm_t *srn_sm_init(srn_context_t *ctx) {
 
  srn_sm_t *sm       = srn_mm_immortal_allocate(ctx->engine->mm, srn_sm_t);
  sm->ctx            = ctx;
  sm->buffers        = array_list_empty(ctx);
  sm->buffer_counts  = 0;
  sm->file_to_id_map = hmap_empty(ctx);
 
  srn_fiber_mutex_init(&sm->write_lock);
 
  return sm;
}
 
static srn_error_t *free_each_buffer_chain(array_list_t *al, size_t n, void *data) {
  UNUSED(n);
  srn_sm_buffer_t *buffer = data;
 
  while (buffer != nullptr) {
    srn_sm_buffer_t *next = buffer->next;
    if (buffer->data != nullptr) {
      FREE(al->ctx, buffer->data);
    }
 
    FREE(al->ctx, (void *)buffer->filename);
    FREE(al->ctx, buffer);
 
    buffer = next;
  }
  return nullptr;
}
 
void srn_sm_shutdown(srn_sm_t *sm) {
  auto err = array_list_for_each(&sm->buffers, free_each_buffer_chain);
  if (err != nullptr) {
    PANIC(err->msg);
  }
  // buffers and file_to_id_map are arena-allocated and freed with the context
  sm->buffer_counts = 0;
}
 
srn_sm_buffer_t *srn_sm_get_buffer(srn_sm_t *sm, srn_sm_buffer_id_t id) {
  if ((id >= 0) && (id < sm->buffer_counts)) {
    SM_TRACEPOINT(get_buffer, id);
    auto maybe_buffer = array_list_get(&sm->buffers, id);
    PANIC_IF(HAS_ERROR(maybe_buffer), "Can't look up the source buffer id");
 
    srn_sm_buffer_t *buffer = maybe_buffer.data;
    return buffer;
  }
 
  PANIC("Source buffer id is not in the correct range");
}
 
typedef struct maybe_buffer_t {
  ERROR_HEADER;
  unsigned char *buffer;
  size_t len;
} maybe_buffer_t;
 
static inline maybe_buffer_t read_file(srn_sm_t *sm, const char *filepath) {
  maybe_buffer_t result = {nullptr, nullptr, 0};
 
  SM_TRACEPOINT(read_file, filepath);
  int fd = open(filepath, O_RDONLY);
 
  if (fd < 0) {
    // Classify the failure from errno, captured before any other call can
    // overwrite it. UNKNOWN_IO_ERROR covers errnos with no dedicated tag.
    srn_error_tag_t tag = srn_errno_to_tag(errno, UNKNOWN_IO_ERROR);
    result.maybe_error  = ERR(sm->ctx, tag, "Failed to open the file.");
    return result;
  }
 
  struct stat st;
  if (fstat(fd, &st) < 0) {
    srn_error_tag_t tag = srn_errno_to_tag(errno, UNKNOWN_IO_ERROR);
    close(fd);
    result.maybe_error = ERR(sm->ctx, tag, "Failed to stat the file.");
    return result;
  }
 
  if (S_ISDIR(st.st_mode)) {
    close(fd);
    result.maybe_error =
      ERR(sm->ctx, IS_A_DIRECTORY, "The path points to a directory, not a file.");
    return result;
  }
 
  if (!S_ISREG(st.st_mode)) {
    close(fd);
    result.maybe_error =
      ERR(sm->ctx, INVALID_ARGUMENT, "The path does not point to a regular file.");
    return result;
  }
 
  // An empty file has no pages to map. Return success with buffer == nullptr;
  // callers treat that as a valid zero-length source.
  if (st.st_size == 0) {
    close(fd);
    return result;
  }
 
  unsigned char *buf =
    srn_mm_malloc(sm->ctx->engine->mm, st.st_size + 1); // plus the null terminator
  PANIC_IF_NULL(buf);
 
  // A single read may return fewer bytes than the file holds, so keep reading
  // until the size reported by `fstat` is in or the descriptor reports end of
  // file. The terminator goes right after the bytes actually read, because
  // that is what the reader stops on.
  size_t total = 0;
  while (total < (size_t)st.st_size) {
    srn_io_size_result_t r;
    SRN_WITH_RETRY(r.maybe_error, {
      r = srn_fiber_read(fd, buf + total, (size_t)st.st_size - total, -1);
    });
    if (HAS_ERROR(r)) {
      close(fd);
      srn_mm_free(sm->ctx->engine->mm, buf);
      // The IO layer hands back one of the reactor's static errors, which
      // must not be traced into. Own a copy and trace that.
      result.maybe_error = ERR_FROM(sm->ctx, r.maybe_error);
      return result;
    }
    if (r.count == 0) {
      break;
    }
    total += r.count;
  }
  close(fd);
  buf[total] = '\0';
 
  result.buffer = buf;
  result.len    = total + 1;
  return result;
}
 
srn_sm_maybe_id_t srn_sm_read_buffer_file(srn_sm_t *sm, const char *filepath, bool reread) {
  srn_sm_maybe_id_t result;
  result.maybe_error = nullptr;
 
  SM_TRACEPOINT(read_buffer_file, filepath, reread);
 
  hmap_key_t k;
  k.data = (void *)filepath;
  k.len  = strnlen(filepath, PATH_MAX);
 
  // Snapshot the map struct under the lock, an insert replaces the two word
  // struct in place and an unsynchronised reader could see a torn root and
  // length pair. CHAMT nodes are immutable, so the walk runs outside it.
  hmap_t snapshot;
  WITH_LOCK(&sm->write_lock, { snapshot = sm->file_to_id_map; });
  auto maybe_buf_id = hmap_lookup(&snapshot, &k, (void *)SRN_SM_NO_ID);
 
  if ((uintptr_t)maybe_buf_id == SRN_SM_NO_ID) {
    // It's a new file
    SM_TRACEPOINT(read_buffer_file_new);
    auto maybe_buffer = read_file(sm, filepath);
 
    if (HAS_ERROR(maybe_buffer)) {
      PUSH_AND_MOVE(sm->ctx, maybe_buffer, result);
      return result;
    }
 
    srn_sm_buffer_t *buf = MALLOC(sm->ctx, srn_sm_buffer_t);
    PANIC_IF_NULL(buf);
 
    buf->data = maybe_buffer.buffer;
    buf->len  = maybe_buffer.len;
    buf->next = nullptr;
    // Buffers live until shutdown, the caller's path string does not.
    buf->filename = srn_dup_str(sm->ctx->engine->mm, filepath);
    PANIC_IF_NULL(buf->filename);
 
    bool lost_race = false;
    WITH_LOCK(&sm->write_lock, {
      // The file was read outside the lock, so another fiber may have loaded
      // the same path in the meantime. Its slot wins and ours is dropped
      // below, which keeps one slot per path.
      void *again = hmap_lookup(&sm->file_to_id_map, &k, (void *)SRN_SM_NO_ID);
      if ((uintptr_t)again != SRN_SM_NO_ID) {
        result.id = (srn_sm_buffer_id_t)(uintptr_t)again;
        lost_race = true;
      } else if (sm->buffer_counts >= UINT16_MAX) {
        // We need to limit the buffer ids to UINT16_MAX since the location stores the id as
        // a 16bit number. If we ever need more than that, we should adjust the limit both here
        // and in the location struct.
        result.maybe_error =
          ERR(sm->ctx, SM_BUFFER_ID_EXHAUSTED, "source manager: buffer ID space exhausted");
      } else {
        // The slot goes in before the map entry, so a failed push leaves no
        // id in the map that points at nothing. No `return` inside this
        // block, the lock is only released after it.
        result.maybe_error = array_list_push(&sm->buffers, buf);
        if (result.maybe_error == nullptr) {
          sm->file_to_id_map = hmap_insert(&sm->file_to_id_map, &k, (void *)sm->buffer_counts);
          result.id          = sm->buffer_counts;
          sm->buffer_counts++;
        }
      }
    });
 
    if (HAS_ERROR(result) || lost_race) {
      srn_mm_free(sm->ctx->engine->mm, buf->data);
      srn_mm_free(sm->ctx->engine->mm, (void *)buf->filename);
      srn_mm_free(sm->ctx->engine->mm, buf);
    }
    return result;
  }
 
  auto buffer_id = (srn_sm_buffer_id_t)maybe_buf_id;
  // We have already read this file once.
  auto buffer = srn_sm_get_buffer(sm, buffer_id);
 
  // At this point buffer being null is a bug
  PANIC_IF_NULL(buffer);
 
  if (reread) {
    auto maybe_new_buffer = read_file(sm, filepath);
    if (HAS_ERROR(maybe_new_buffer)) {
      PUSH_AND_MOVE(sm->ctx, maybe_new_buffer, result);
      return result;
    }
 
    srn_sm_buffer_t *buf = MALLOC(sm->ctx, srn_sm_buffer_t);
    PANIC_IF_NULL(buf);
 
    buf->data     = maybe_new_buffer.buffer;
    buf->len      = maybe_new_buffer.len;
    buf->next     = buffer;
    buf->filename = srn_dup_str(sm->ctx->engine->mm, filepath);
    PANIC_IF_NULL(buf->filename);
 
    WITH_LOCK(&sm->write_lock, {
      /* sm->file_to_id_map = hmap_insert(&sm->file_to_id_map, &k, (void *)buffer_id); */
 
      auto update_err = array_list_update(&sm->buffers, buffer_id, buf);
      PANIC_IF(update_err != nullptr, "failed to update source buffer slot");
    });
  }
 
  result.id = buffer_id;
  return result;
}
 
srn_sm_maybe_buffer_t srn_sm_buffer_file(srn_sm_t *sm, const char *filepath, bool reread) {
  srn_sm_maybe_buffer_t result = {nullptr, nullptr};
  auto maybe_id                = srn_sm_read_buffer_file(sm, filepath, reread);
 
  if (HAS_ERROR(maybe_id)) {
    PUSH_AND_MOVE(sm->ctx, maybe_id, result);
    return result;
  }
 
  // NOTE: buffer can be nullptr, it means an empty file
  result.buffer = srn_sm_get_buffer(sm, maybe_id.id);
 
  return result;
}