root/trunk/mmap.c @ 1

#undef ALLOC_DEBUG

#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
/* mmap */
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>

#include "php.h"
#include "myshm.h"

#ifndef max
#define max(a, b) ((a) < (b) ? (b) : (a))
#endif

// {{{ xc_shm_t
struct _xc_shm_t {
    void *ptr;
    void *ptr_ro;
    long  diff;
    xc_shmsize_t size;
};

#ifdef ALLOC_DEBUG
#   undef NDEBUG
#   define inline
#else
#   define NDEBUG
#endif
#include <assert.h>
/* }}} */
#define CHECK(x, e) do { if ((x) == NULL) { zend_error(E_ERROR, "XCache: " e); goto err; } } while (0)

int xc_shm_can_readonly(xc_shm_t *shm) /* {{{ */
{
    return shm->ptr_ro != NULL;
}
/* }}} */
int xc_shm_is_readwrite(xc_shm_t *shm, const void *p) /* {{{ */
{
    return p >= shm->ptr && (char *)p < (char *)shm->ptr + shm->size;
}
/* }}} */
int xc_shm_is_readonly(xc_shm_t *shm, const void *p) /* {{{ */
{
    return xc_shm_can_readonly(shm) && p >= shm->ptr_ro && (char *)p < (char *)shm->ptr_ro + shm->size;
}
/* }}} */
void *xc_shm_to_readwrite(xc_shm_t *shm, void *p) /* {{{ */
{
    if (shm->diff) {
        assert(xc_shm_is_readonly(p));
        p = p - shm->diff;
    }
    assert(xc_shm_is_readwrite(p));
    return p;
}
/* }}} */
void *xc_shm_to_readonly(xc_shm_t *shm, void *p) /* {{{ */
{
    assert(xc_shm_is_readwrite(p));
    if (shm->diff) {
        p = p + shm->diff;
        assert(xc_shm_is_readonly(p));
    }
    return p;
}
/* }}} */

void xc_shm_destroy(xc_shm_t *shm) /* {{{ */
{
    if (shm->ptr_ro) {
        munmap(shm->ptr_ro, shm->size);
        /*
        shm->ptr_ro = NULL;
        */
    }
    if (shm->ptr) {
        /* shm->size depends on shm->ptr */
        munmap(shm->ptr, shm->size);
        /*
        shm->ptr = NULL;
        */
    }
    /*
    shm->size = NULL;
    shm->diff = 0;
    */

    free(shm);
    return;
}
/* }}} */
xc_shm_t *xc_shm_init(const char *path, xc_shmsize_t size, zend_bool readonly_protection) /* {{{ */
{
    xc_shm_t *shm = NULL;
    int fd;
    int ro_ok;
    volatile void *romem;
    int created = 0;

    CHECK(shm = calloc(1, sizeof(xc_shm_t)), "shm OOM");
    shm->size = size;
    if (path == NULL || !path[0]) {
        path = "/tmp/xcache";
    }
    fd = open(path, O_RDWR, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        created = 1;
        fd = open(path, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
        if (fd == -1) {
            if (created) {
                unlink(path);
            }
            goto err;
        }
    }
    ftruncate(fd, size);

    shm->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shm->ptr == MAP_FAILED) {
        shm->ptr = NULL;
        close(fd);
        if (created) {
            unlink(path);
        }
        goto err;
    }

    ro_ok = 0;
    if (readonly_protection) {
        shm->ptr_ro = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
        romem = shm->ptr_ro;

        /* {{{ check if ptr_ro works */
        do {
            if (shm->ptr_ro == MAP_FAILED || shm->ptr_ro == shm->ptr) {
                break;
            }
            *(char *)shm->ptr = 1;
            if (*(char *)romem != 1) {
                break;
            }
            *(char *)shm->ptr = 2;
            if (*(char *)romem != 2) {
                break;
            }
            ro_ok = 1;
        } while (0);
    }

    if (ro_ok) {
        shm->diff = shm->ptr_ro - shm->ptr;
        assert(abs(shm->diff) >= size);
    }
    else {
        if (shm->ptr_ro != MAP_FAILED) {
            munmap(shm->ptr_ro, size);
        }
        shm->ptr_ro = NULL;
        shm->diff = 0;
    }
    /* }}} */

    close(fd);
    if (created) {
        unlink(path);
    }

    return shm;

err:
    if (shm) {
        xc_shm_destroy(shm);
    }
    return NULL;
}
/* }}} */

void *xc_shm_ptr(xc_shm_t *shm) /* {{{ */
{
    return shm->ptr;
}
/* }}} */