source_manager.c File Reference

#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"

Include dependency graph for source_manager.c:

Go to the source code of this file.

Data Structures
struct	maybe_buffer_t

Typedefs
typedef struct maybe_buffer_t	maybe_buffer_t

Functions
srn_sm_t *	srn_sm_init (srn_context_t *ctx)
	Initialize the source manager, as an immortal data structure.
static srn_error_t *	free_each_buffer_chain (array_list_t *al, size_t n, void *data)
void	srn_sm_shutdown (srn_sm_t *sm)
	Shutdown the source manager freeing all the buffers.
srn_sm_buffer_t *	srn_sm_get_buffer (srn_sm_t *sm, srn_sm_buffer_id_t id)
	Return the buffer pointer of the given id, nullptr if the id does not exists.
static maybe_buffer_t	read_file (srn_sm_t *sm, const char *filepath)
srn_sm_maybe_id_t	srn_sm_read_buffer_file (srn_sm_t *sm, const char *filepath, bool reread)
	Read and buffer the given filepath into the source manager and return the buffer id.
srn_sm_maybe_buffer_t	srn_sm_buffer_file (srn_sm_t *sm, const char *filepath, bool reread)
	Read and buffer the given filepath into the source manager and return a srn_sm_maybe_buffer_t which either fails or has a pointer to the buffer containing the content of the file.

Typedef Documentation

maybe_buffer_t

typedef struct maybe_buffer_t maybe_buffer_t

Function Documentation

free_each_buffer_chain()

srn_error_t * free_each_buffer_chain ( array_list_t * al, size_t n, void * data )

static

Definition at line 50 of file source_manager.c.

                                                                                   {
  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;
}

Here is the caller graph for this function:

read_file()

maybe_buffer_t read_file ( srn_sm_t * sm, const char * filepath )

inlinestatic

Definition at line 96 of file source_manager.c.

                                                                           {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sm_buffer_file()

srn_sm_maybe_buffer_t srn_sm_buffer_file	(	srn_sm_t *	sm,
		const char *	filepath,
		bool	reread )

Read and buffer the given filepath into the source manager and return a srn_sm_maybe_buffer_t which either fails or has a pointer to the buffer containing the content of the file.

A nullptr for the buffer means an empty file.

Definition at line 282 of file source_manager.c.

                                                                                          {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sm_get_buffer()

srn_sm_buffer_t * srn_sm_get_buffer	(	srn_sm_t *	sm,
		srn_sm_buffer_id_t	id )

Return the buffer pointer of the given id, nullptr if the id does not exists.

Definition at line 77 of file source_manager.c.

                                                                        {
  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");
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sm_init()

srn_sm_t * srn_sm_init

(

srn_context_t *

ctx

)

Initialize the source manager, as an immortal data structure.

The buffers themselves will NOT be managed by the the memory manager.

Definition at line 37 of file source_manager.c.

                                          {
 
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sm_read_buffer_file()

srn_sm_maybe_id_t srn_sm_read_buffer_file	(	srn_sm_t *	sm,
		const char *	filepath,
		bool	reread )

Read and buffer the given filepath into the source manager and return the buffer id.

If the file already exists, it will just return the buffer id, unless the reread is true, which will reread the file and populate the buffer. It will NOT overwrite the old buffer.

Definition at line 174 of file source_manager.c.

                                                                                           {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sm_shutdown()

void srn_sm_shutdown

(

srn_sm_t *

sm

)

Shutdown the source manager freeing all the buffers.

After this call all the pointers into the buffers will be invalid.

Definition at line 68 of file source_manager.c.

                                   {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function: