tests/fs/test_mmap.c

/*
 * Copyright 2015 The Emscripten Authors.  All rights reserved.
 * Emscripten is available under two separate licenses, the MIT license and the
 * University of Illinois/NCSA Open Source License.  Both these licenses can be
 * found in the LICENSE file.
 */

#include <stdio.h>
#include <sys/mman.h>
#include <emscripten.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/io.h>
#include <errno.h>

int main() {
  EM_ASM(
    FS.mkdir('yolo');
    #if NODEFS
        FS.mount(NODEFS, { root: '.' }, 'yolo');
    #endif
    FS.writeFile('yolo/in.txt', 'mmap ftw!');
  );

  // Use mmap to read in.txt
  {
    const char* path = "yolo/in.txt";
    int fd = open(path, O_RDONLY);
    assert(fd != -1);

    int filesize = 9;
    char* map = (char*)mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
    assert(map != MAP_FAILED);

    printf("yolo/in.txt content=");
    for (int i = 0; i < filesize; i++) {
        printf("%c", map[i]);
    }
    printf("\n");

    int rc = munmap(map, filesize);
    assert(rc == 0);

    close(fd);
  }

  // Use mmap to write out.txt
  {
    const char* text = "written mmap";
    const char* path = "yolo/out.txt";

    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
    assert(fd != -1);

    size_t textsize = strlen(text) + 1; // + \0 null character
    assert(lseek(fd, textsize - 1, SEEK_SET) != -1);

    // need to write something first to allow us to mmap
    assert(write(fd, "", 1) != -1);

    char *map = (char*)mmap(0, textsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    assert(map != MAP_FAILED);

    for (size_t i = 0; i < textsize; i++) {
      map[i] = text[i];
    }

    assert(msync(map, textsize, MS_SYNC) != -1);

    assert(munmap(map, textsize) != -1);

    close(fd);
  }

  {
    FILE* fd = fopen("yolo/out.txt", "r");
    if (fd == NULL) {
      printf("failed to open yolo/out.txt\n");
      return 1;
    }
    char buffer[15];
    memset(buffer, 0, 15);
    fread(buffer, 1, 14, fd);
    printf("yolo/out.txt content=%s\n", buffer);
    fclose(fd);
  }

  // Use mmap to read out.txt and modify the contents in memory,
  // but make sure it's not overwritten on munmap
  {
    const char* readonlytext = "readonly mmap\0";
    const char* text = "write mmap\0";
    const char* path = "yolo/outreadonly.txt";
    size_t readonlytextsize = strlen(readonlytext);
    size_t textsize = strlen(text);

    int fd = open(path, O_RDWR | O_CREAT, (mode_t)0600);
    // write contents to the file ( we don't want this to be overwritten on munmap )
    assert(write(fd, readonlytext, readonlytextsize) != -1);
    close(fd);    

    fd = open(path, O_RDWR);
    char *map = (char*)mmap(0, textsize, PROT_READ, MAP_SHARED, fd, 0);
    assert(map != MAP_FAILED);
    
    for (size_t i = 0; i < textsize; i++) {
      map[i] = text[i];
    }

    assert(munmap(map, textsize) != -1);
    close(fd);
  }

  {
    FILE* fd = fopen("yolo/outreadonly.txt", "r");
    if (fd == NULL) {
      printf("failed to open yolo/outreadonly.txt\n");
      return 1;
    }
    char buffer[16];
    memset(buffer, 0, 16);
    fread(buffer, 1, 15, fd);
    printf("yolo/outreadonly.txt content=%s\n", buffer);
    fclose(fd);
  }

  // MAP_PRIVATE
  {
    const char* text = "written mmap";
    const char* path = "yolo/private.txt";

    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
    assert(fd != -1);

    size_t textsize = strlen(text) + 1; // + \0 null character
    assert(lseek(fd, textsize - 1, SEEK_SET) != -1);

    // need to write something first to allow us to mmap
    assert(write(fd, "", 1) != -1);

    char *map = (char*)mmap(0, textsize, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    assert(map != MAP_FAILED);

    for (size_t i = 0; i < textsize; i++) {
      map[i] = text[i];
    }

    assert(msync(map, textsize, MS_SYNC) != -1);

    assert(munmap(map, textsize) != -1);

    close(fd);
  }

  {
    FILE* fd = fopen("yolo/private.txt", "r");
    if (fd == NULL) {
      printf("failed to open yolo/private.txt\n");
      return 1;
    }
    char buffer[15];
    memset(buffer, 0, 15);
    fread(buffer, 1, 14, fd);
    printf("yolo/private.txt content=%s\n", buffer);
    fclose(fd);
  }

  // MAP_SHARED with offset
  {
    const char* text = "written shared mmap with offset";
    const char* path = "yolo/sharedoffset.txt";

    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
    assert(fd != -1);

    size_t textsize = strlen(text) + 1; // + \0 null character
    // offset must be a multiple of the page size as returned by sysconf(_SC_PAGE_SIZE).
    size_t offset = sysconf(_SC_PAGE_SIZE) * 2;

    assert(lseek(fd, textsize + offset - 1, SEEK_SET) != -1);

    // need to write something first to allow us to mmap
    assert(write(fd, "", 1) != -1);

    char *map;
    map = (char*)mmap(0, textsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset - 1);
    // assert failure if offset is not a multiple of page size
    assert(map == MAP_FAILED);

    map = (char*)mmap(0, textsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
    assert(map != MAP_FAILED);

    for (size_t i = 0; i < textsize; i++) {
      map[i] = text[i];
    }

    assert(msync(map, textsize, MS_SYNC) != -1);

    assert(munmap(map, textsize) != -1);

    close(fd);
  }

  // mmap with a address will fail
  {
    const char* path = "yolo/private.txt";

    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
    assert(fd != -1);

    size_t map_size = 1 << 16;

    // Reserve some address space in which to perform the experiment
    char *alloc = (char*)mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    assert(alloc != MAP_FAILED);

    char *addr = (char*)mmap((void*)alloc, map_size, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, 0);
    assert(addr == MAP_FAILED && errno == EINVAL); // Emscripten
    //assert(addr == alloc); // Native environments

    assert(munmap(alloc, map_size) != -1);
    close(fd);
  }

  {
    FILE* fd = fopen("yolo/sharedoffset.txt", "r");
    if (fd == NULL) {
      printf("failed to open yolo/sharedoffset.txt\n");
      return 1;
    }
    size_t offset = sysconf(_SC_PAGE_SIZE) * 2;
    
    char buffer[offset + 33];
    memset(buffer, 0, offset + 33);
    fread(buffer, 1, offset + 32, fd);
    // expect text written from mmap operation to appear at offset in the file
    printf("yolo/sharedoffset.txt content=%s %zu\n", buffer + offset, offset);
    fclose(fd);
  }

#if !defined(NODEFS) && !defined(NODERAWFS)
  /**
   * MMAP to an 'over-allocated' file
   * 
   * When appending to a file, the buffer size is increased in chunks, and so the actual length
   * of the file could be less than the buffer size.
   * 
   * When using mmap for an over-allocated file, we have to make sure that content from the buffer
   * is not written beyond the allocated memory area for the mmap operation.
   */
  {
    int fd = open("yolo/overallocatedfile.txt", O_RDWR | O_CREAT, (mode_t)0600);
    assert(fd != -1);

    const size_t textsize = 33;

    // multiple calls to write so that the file will be over-allocated
    for (int n = 0; n < textsize; n++) {
      assert(write(fd, "a", 1) != -1);
    }

    EM_ASM_({
        const stream = FS.streams.find(stream => stream.path.indexOf('yolo/overallocatedfile.txt') >= 0);
        assert(stream.node.usedBytes === $0,
          'Used bytes on the over-allocated file (' + stream.node.usedBytes + ') ' +
          'should be 33'
        );
        assert(stream.node.contents.length > stream.node.usedBytes,
          'Used bytes on the over-allocated file (' + stream.node.usedBytes + ') ' +
          'should be less than the length of the content buffer (' + stream.node.contents.length + ')'
        );
        stream.node.contents[stream.node.usedBytes] = 98; // 'b', we don't want to see this in the mmap area
    }, textsize);

    char *map = (char*)mmap(NULL, textsize, PROT_READ, 0, fd, 0);

    assert(map[textsize-1] == 'a');

    // Assert that content from the over-allocated file buffer is not written beyond the allocated memory for the map
#if !__has_feature(address_sanitizer) // the following is invalid, and asan complains rightfully
    assert(map[textsize] != 'b');
#endif

    close(fd);
  }
#endif

  return 0;
}