mmap

memory-map/mmap_test.c

@@ -6,23 +6,18 @@
 
 void test1()
 {
-    const int wflags =
-            SC_MMAP_FILE_READWRITE | SC_MMAP_FILE_CREATE | SC_MMAP_FILE_TRUNC;
-    const int mwflags = SC_MMAP_MAP_READ | SC_MMAP_MAP_WRITE;
-    const int rflags = SC_MMAP_FILE_READ;
-    const int mrflags = SC_MMAP_MAP_READ;
     int rc;
     char* p;
     struct sc_mmap mmap;
 
-    rc = sc_mmap_init(&mmap, "/tmp/x.txt", wflags, mwflags, true, 0, 4095);
+    rc = sc_mmap_init(&mmap, "/tmp/x.txt", O_RDWR | O_CREAT | O_TRUNC, PROT_READ | PROT_WRITE, MAP_SHARED, 0, 4095);
     assert(rc == 0);
     rc = sc_mmap_msync(&mmap, 0, 4096);
     assert(rc == 0);
     rc = sc_mmap_term(&mmap);
     assert(rc == 0);
 
-    rc = sc_mmap_init(&mmap, "/tmp/x.txt", wflags, mwflags, true, 0, 8192);
+    rc = sc_mmap_init(&mmap, "/tmp/x.txt", O_RDWR | O_CREAT | O_TRUNC, PROT_READ | PROT_WRITE, MAP_SHARED, 0, 8192);
     assert(rc == 0);
     assert(mmap.len == 8192);
     p = mmap.ptr;
@@ -31,14 +26,14 @@ void test1()
     assert(rc == 0);
     rc = sc_mmap_term(&mmap);
     assert(rc == 0);
-    rc = sc_mmap_init(&mmap, "/tmp/x.txt", rflags, mrflags, true, 0, 4095);
+    rc = sc_mmap_init(&mmap, "/tmp/x.txt", O_RDONLY, PROT_READ, MAP_SHARED, 0, 0);
     assert(rc == 0);
     p = mmap.ptr;
     assert(*p == 'x');
     rc = sc_mmap_term(&mmap);
     assert(rc == 0);
 
-    rc = sc_mmap_init(&mmap, "/tmp/x.txt", rflags, mwflags, true, 0, 4095);
+    rc = sc_mmap_init(&mmap, "/tmp/x.txt" ,O_RDWR | O_CREAT | O_TRUNC, PROT_READ | PROT_WRITE, MAP_SHARED, 3, 4095);
     assert(rc == -1);
 }
 

memory-map/sc_mmap.c

@@ -1,25 +1,169 @@
+
 #include "sc_mmap.h"
 
 #include <errno.h>
 #include <fcntl.h>
-#include <stdio.h>
 #include <string.h>
-#include <sys/mman.h>
 #include <sys/stat.h>
-#include <unistd.h>
 
-int sc_mmap_init(struct sc_mmap *m, const char *name, int file_flags,
-                 int map_flags, bool shared, size_t offset, size_t len)
+
+#if defined(_WIN32)
+#include <io.h>
+
+#pragma warning(disable : 4996)
+
+static void sc_mmap_err(struct sc_mmap* m)
 {
-    const int mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-    int s;
+    int rc;
+    DWORD err = GetLastError();
+    LPSTR errstr = 0;
+
+    rc = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM,
+        NULL, err, 0, (LPSTR)&errstr, 0, NULL);
+    if (rc != 0) {
+        strncpy(m->err, errstr, sizeof(m->err) - 1);
+        LocalFree(errstr);
+    }
+}
+
+int sc_mmap_init(struct sc_mmap* m, const char* name, int file_flags, int prot,
+    int map_flags, size_t offset, size_t len)
+{
+    const int mode = prot & PROT_WRITE ? _S_IREAD | _S_IWRITE : _S_IREAD;
+    struct _stat64 st;
+    int fd, rc;
+    void* p = NULL;
+    BOOL b;
+
+    *m = (struct sc_mmap){ 0 };
+
+    fd = _open(name, file_flags, mode);
+    if (fd == -1) {
+        goto error;
+    }
+
+    rc = _stat64(name, &st);
+    if (rc != 0) {
+        goto cleanup_fd;
+    }
+
+    len = (len == 0) ? st.st_size - offset : len;
+
+    HANDLE fm, h = INVALID_HANDLE_VALUE;
+    const size_t max_size = offset + len;
+
+    const DWORD offset_low = (DWORD)(offset & 0xFFFFFFFFL);
+    const DWORD offset_high = (DWORD)((offset >> 32) & 0xFFFFFFFFL);
+    const DWORD size_low = (DWORD)(max_size & 0xFFFFFFFFL);
+    const DWORD size_high = (DWORD)((max_size >> 32) & 0xFFFFFFFFL);
+    const DWORD protect = (prot & PROT_WRITE) ? PAGE_READWRITE : PAGE_READONLY;
+
+    if ((map_flags & MAP_ANONYMOUS) == 0) {
+        h = (HANDLE)_get_osfhandle(fd);
+        if (h == INVALID_HANDLE_VALUE) {
+            goto cleanup_fd;
+        }
+    }
+
+    fm = CreateFileMapping(h, NULL, protect, size_high, size_low, NULL);
+    if (fm == NULL) {
+        goto cleanup_fd;
+    }
+
+    p = MapViewOfFile(fm, prot, offset_high, offset_low, len);
+
+    CloseHandle(fm);
+
+    if (p == NULL) {
+        goto cleanup_fd;
+    }
+
+    m->ptr = p;
+    m->len = len;
+
+    _close(fd);
+
+    return 0;
+
+cleanup_fd:
+    _close(fd);
+error:
+    sc_mmap_err(m);
+
+    return -1;
+}
+
+int sc_mmap_msync(struct sc_mmap* m, size_t offset, size_t len)
+{
+    BOOL b;
+    char* p = (char*)m->ptr + offset;
+
+    b = FlushViewOfFile(p, len);
+    if (b == 0) {
+        sc_mmap_err(m);
+        return -1;
+    }
+
+    return 0;
+}
+
+int sc_mmap_mlock(struct sc_mmap* m, size_t offset, size_t len)
+{
+    BOOL b;
+    char* p = (char*)m->ptr + offset;
+
+    b = VirtualLock((LPVOID)p, len);
+    if (b == 0) {
+        sc_mmap_err(m);
+        return -1;
+    }
+
+    return 0;
+}
+
+int sc_mmap_munlock(struct sc_mmap* m, size_t offset, size_t len)
+{
+    BOOL b;
+    char* p = (char*)m->ptr + offset;
 
-    *m = (struct sc_mmap){0};
+    b = VirtualUnlock((LPVOID)p, len);
+    if (b == 0) {
+        sc_mmap_err(m);
+        return -1;
+    }
+
+    return 0;
+}
 
+int sc_mmap_term(struct sc_mmap* m)
+{
+    BOOL b;
+
+    b = UnmapViewOfFile(m->ptr);
+    if (b == 0) {
+        sc_mmap_err(m);
+        return -1;
+    }
+
+    return 0;
+}
+
+#else
+
+
+
+#include <unistd.h>
+
+int sc_mmap_init(struct sc_mmap* m, const char* name, int file_flags, int prot,
+    int map_flags, size_t offset, size_t len)
+{
+    const int mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
     struct stat st;
     int fd, rc, saved_errno;
-    size_t size;
-    void *p = NULL;
+    void* p = NULL;
+
+    *m = (struct sc_mmap){ 0 };
 
     fd = open(name, file_flags, mode);
     if (fd == -1) {
@@ -31,32 +175,20 @@ int sc_mmap_init(struct sc_mmap *m, const char *name, int file_flags,
         goto cleanup_fd;
     }
 
-    size = st.st_size;
-
-    if (len > size) {
-        size_t seek, written;
-        size_t block = st.st_blksize;
-        size_t pos = (size / block) * block + block - 1;
-
-        for (; pos < len + block - 1; pos += block) {
-            if (pos >= len) {
-                pos = len - 1;
-            }
+    len = (len == 0) ? st.st_size - offset : len;
 
-            seek = lseek(fd, pos, SEEK_SET);
-            if (seek == -1) {
-                goto cleanup_fd;
-            }
+    if (prot & PROT_WRITE) {
+        do {
+            rc = posix_fallocate(fd, offset, len);
+        } while (rc == EINTR);
 
-            written = write(fd, "", 1);
-            if (written != 1) {
-                goto cleanup_fd;
-            }
+        if (rc != 0) {
+            errno = rc;
+            goto cleanup_fd;
         }
     }
 
-    s = shared ? MAP_SHARED : MAP_PRIVATE;
-    p = mmap(NULL, len, map_flags, s, fd, offset);
+    p = mmap(NULL, len, prot, map_flags, fd, offset);
     if (p == MAP_FAILED) {
         goto cleanup_fd;
     }
@@ -71,16 +203,29 @@ int sc_mmap_init(struct sc_mmap *m, const char *name, int file_flags,
 cleanup_fd:
     saved_errno = errno;
     close(fd);
+    errno = saved_errno;
 error:
-    strcpy(m->err, strerror(saved_errno));
+    strcpy(m->err, strerror(errno));
 
     return -1;
 }
 
-int sc_mmap_msync(struct sc_mmap *m, size_t offset, size_t len)
+int sc_mmap_term(struct sc_mmap* m)
 {
     int rc;
-    char *p = (char *) m->ptr + offset;
+
+    rc = munmap(m->ptr, m->len);
+    if (rc != 0) {
+        strcpy(m->err, strerror(errno));
+    }
+
+    return rc;
+}
+
+int sc_mmap_msync(struct sc_mmap* m, size_t offset, size_t len)
+{
+    int rc;
+    char* p = (char*)m->ptr + offset;
 
     rc = msync(p, len, MS_SYNC);
     if (rc != 0) {
@@ -90,14 +235,30 @@ int sc_mmap_msync(struct sc_mmap *m, size_t offset, size_t len)
     return rc;
 }
 
-int sc_mmap_term(struct sc_mmap *m)
+int sc_mmap_mlock(struct sc_mmap* m, size_t offset, size_t len)
 {
     int rc;
+    char* p = (char*)m->ptr + offset;
 
-    rc = munmap(m->ptr, m->len);
+    rc = mlock(p, len);
     if (rc != 0) {
         strcpy(m->err, strerror(errno));
     }
 
     return rc;
 }
+
+int sc_mmap_munlock(struct sc_mmap* m, size_t offset, size_t len)
+{
+    int rc;
+    char* p = (char*)m->ptr + offset;
+
+    rc = munlock(p, len);
+    if (rc != 0) {
+        strcpy(m->err, strerror(errno));
+    }
+
+    return rc;
+}
+
+#endif

memory-map/sc_mmap.h

@@ -1,33 +1,42 @@
 #ifndef SC_MMAP_H
 #define SC_MMAP_H
 
-#include <stdlib.h>
-#include <stdbool.h>
 #include <fcntl.h>
-#include <sys/mman.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#if defined(_WIN32)
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <windows.h>
+#include <memoryapi.h>
 
-#define SC_MMAP_FILE_READ      O_RDONLY
-#define SC_MMAP_FILE_READWRITE O_RDWR
-#define SC_MMAP_FILE_CREATE    O_CREAT
-#define SC_MMAP_FILE_TRUNC     O_TRUNC
 
-#define SC_MMAP_MAP_READ  PROT_READ
-#define SC_MMAP_MAP_WRITE PROT_WRITE
-#define SC_MMAP_MAP_EXEC  PROT_EXEC
+#define PROT_READ  FILE_MAP_READ
+#define PROT_WRITE FILE_MAP_WRITE
 
+#define MAP_FIXED     0x01
+#define MAP_ANONYMOUS 0x02
+#define MAP_SHARED    0x04
+
+#else /*POSIX*/
+
+#include <sys/mman.h>
+
+#endif
 
 struct sc_mmap
 {
-    void *ptr;
+    void* ptr;
     size_t len;
     char err[64];
 };
 
-int sc_mmap_init(struct sc_mmap *m, const char *name, int file_flags, int map_flags,
-                 bool shared, size_t offset, size_t len);
-
-int sc_mmap_msync(struct sc_mmap *m, size_t offset, size_t len);
-int sc_mmap_term(struct sc_mmap *m);
-
+int sc_mmap_init(struct sc_mmap* m, const char* name, int file_flags, int prot,
+                 int map_flags, size_t offset, size_t len);
+int sc_mmap_msync(struct sc_mmap* m, size_t offset, size_t len);
+int sc_mmap_mlock(struct sc_mmap* m, size_t offset, size_t len);
+int sc_mmap_munlock(struct sc_mmap* m, size_t offset, size_t len);
+int sc_mmap_term(struct sc_mmap* m);
 
 #endif