srn_mmap.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/utils/srn_mmap.h"
 
#if PMAP_WIN32
 
#  include <io.h>
 
#  include "serene/rt/context.h"
#  include "serene/rt/errors.h"
 
static DWORD get_allocation_granularity(void) {
  static DWORD granularity;
  SYSTEM_INFO sys;
 
  if (!granularity) {
    GetSystemInfo(&sys);
    granularity = sys.dwAllocationGranularity;
  }
 
  return granularity;
}
 
srn_error_t *srn_mmap(
  srn_context_t *ctx, srn_mmap_buffer_t *out, size_t len, int prot, int flags, int fd,
  off64_t offset
) {
  HANDLE fh       = (HANDLE)_get_osfhandle(fd);
  DWORD alignment = get_allocation_granularity();
  DWORD fmap_prot = 0;
  DWORD view_prot = 0;
  DWORD off_low   = 0;
  DWORD off_hi    = 0;
  off64_t page_start;
  off64_t page_offset;
 
  SRN_MMAP_VALIDATE(out, len, prot, flags);
 
  out->data = NULL;
  out->len  = 0;
  out->fmh  = NULL;
 
  if (fh == INVALID_HANDLE_VALUE) {
    return ERR(ctx, MEMORY_MAP_FAILED, "failed to mmap. Invalid handle value");
  }
 
  if (prot & SRN_PROT_WRITE) {
    fmap_prot |= PAGE_READWRITE;
  } else if (prot & SRN_PROT_READ) {
    fmap_prot |= PAGE_READONLY;
  }
 
  if (prot & SRN_PROT_WRITE) {
    view_prot |= FILE_MAP_WRITE;
  }
  if (prot & SRN_PROT_READ) {
    view_prot |= FILE_MAP_READ;
  }
 
  page_start  = (offset / alignment) * alignment;
  page_offset = offset - page_start;
 
  if (page_offset != 0) { // offset must be a multiple of the allocation granularity
    return ERR(
      ctx, MEMORY_MAP_FAILED, "failed to mmap. Offset must be a multiple of allocation granularity"
    );
  }
 
  out->fmh = CreateFileMapping(fh, NULL, fmap_prot, 0, 0, NULL);
  if (!out->fmh || out->fmh == INVALID_HANDLE_VALUE) {
    out->fmh = NULL;
    return ERR(ctx, MEMORY_MAP_FAILED, "failed to mmap. Could not create file mapping");
  }
 
  off_low   = (DWORD)(page_start);
  off_hi    = (DWORD)(page_start >> 32);
  out->data = MapViewOfFile(out->fmh, view_prot, off_hi, off_low, len);
  if (!out->data) {
    CloseHandle(out->fmh);
    out->fmh = NULL;
    return ERR(ctx, MEMORY_MAP_FAILED, "failed to mmap. Could not map view of file");
  }
  out->len = len;
 
  return nullptr;
}
 
int srn_munmap(srn_mmap_buffer_t *map) {
  int error = 0;
 
  PANIC_IF_NULL(map);
 
  if (map->data) {
    if (!UnmapViewOfFile(map->data)) {
      error = -1;
    }
    map->data = NULL;
  }
 
  if (map->fmh) {
    if (!CloseHandle(map->fmh)) {
      error = -1;
    }
    map->fmh = NULL;
  }
 
  map->len = 0;
 
  return error;
}
 
#endif