isomorfeus-ferret 0.14.3 → 0.15.0

data/ext/isomorfeus_ferret_ext/frt_mdbx_store.c

@@ -0,0 +1,691 @@
+#include "frt_store.h"
+#include "frt_lang.h"
+#include <time.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+extern void frt_micro_sleep(const int micro_seconds);
+
+const char *dbi_name = "segmented_index";
+const char *lock_s = "lock";
+
+// helper functions
+
+// txn
+
+static void mdbxs_begin_txn(FrtStore *store, MDBX_txn **txn) {
+    int res = mdbx_txn_begin(store->dir.mdbx->env, NULL, 0, txn);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to begin txn, error: %i\n", res);
+    }
+}
+
+static void mdbxs_begin_ro_txn(FrtStore *store, MDBX_txn **txn) {
+    int res = mdbx_txn_begin(store->dir.mdbx->env, NULL, 0 | MDBX_RDONLY, txn);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to begin read only txn, error: %i\n", res);
+    }
+}
+
+static void mdbxs_commit_txn(MDBX_txn *txn) {
+    int res = mdbx_txn_commit(txn);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to commit txn, error: %i\n", res);
+    }
+}
+
+static void mdbxs_abort_txn(MDBX_txn *txn) {
+    int res = mdbx_txn_abort(txn);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to abort txn, error: %i\n", res);
+    }
+}
+
+// dbi
+
+static void mdbxs_open_dbi(MDBX_txn *txn, const char *dbi_name, MDBX_dbi *dbi) {
+    int res = mdbx_dbi_open(txn, dbi_name, MDBX_DB_DEFAULTS | MDBX_CREATE, dbi);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to open dbi '%s', error: %i\n", dbi_name, res);
+    }
+}
+
+// cursor
+
+static void mdbxs_open_cursor(MDBX_txn *txn, MDBX_dbi dbi, MDBX_cursor **cursor) {
+    int res = mdbx_cursor_open(txn, dbi, cursor);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to open cursor, error: %i\n", res);
+    }
+}
+
+// crud
+
+static void mdbxs_del(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key, MDBX_val *val) {
+    int res = mdbx_del(txn, dbi, key, val);
+    if (res == MDBX_SUCCESS || res == MDBX_NOTFOUND) { return; }
+    FRT_RAISE(FRT_IO_ERROR, "failed to del, error: %i\n", res);
+}
+
+static void mdbxs_put(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key, MDBX_val *val) {
+    int res = mdbx_put(txn, dbi, key, val, 0);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "failed to put, error: %i\n", res);
+    }
+}
+
+// store API
+
+static void mdbxs_touch(FrtStore *store, const char *filename) {
+    int res = 0;
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key, val;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    res = mdbx_get(txn, dbi, &key, &val);
+
+    if (res == MDBX_NOTFOUND) {
+        val.iov_base = NULL;
+        val.iov_len = 0;
+        mdbxs_put(txn, dbi, &key, &val);
+        mdbxs_commit_txn(txn);
+    } else if (res == MDBX_SUCCESS) {
+        mdbxs_abort_txn(txn);
+    } else {
+        mdbxs_abort_txn(txn);
+        FRT_RAISE(FRT_IO_ERROR, "failed to touch '%s', error: %i\n", filename, res);
+    }
+}
+
+static int mdbxs_exists(FrtStore *store, const char *filename) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key, val;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_ro_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    int res = mdbx_get(txn, dbi, &key, &val);
+    mdbxs_abort_txn(txn);
+
+    if (res == MDBX_SUCCESS) { return true; }
+    return false;
+}
+
+static int mdbxs_remove(FrtStore *store, const char *filename) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_del(txn, dbi, &key, NULL);
+    mdbxs_commit_txn(txn);
+
+    return 0;
+}
+
+static void mdbxs_rename(FrtStore *store, const char *from, const char *to) {
+    int res;
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val from_key, to_key, val;
+    from_key.iov_base = (char *)from;
+    from_key.iov_len  = strlen(from);
+    val.iov_base      = NULL;
+    val.iov_len       = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    res = mdbx_get(txn, dbi, &from_key, &val);
+
+    if (res == MDBX_SUCCESS) {
+        to_key.iov_base = (char *)to;
+        to_key.iov_len  = strlen(to);
+
+        mdbxs_put(txn, dbi, &to_key, &val);
+        mdbxs_del(txn, dbi, &from_key, NULL);
+        mdbxs_commit_txn(txn);
+    } else {
+        mdbxs_abort_txn(txn);
+        FRT_RAISE(FRT_FILE_NOT_FOUND_ERROR, "tried to open '%s' but its not accessible, error: %i", from, res);
+    }
+}
+
+static int mdbxs_count(FrtStore *store) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_stat stat;
+    int res = 0;
+    int cnt = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    res = mdbx_dbi_stat(txn, dbi, &stat, sizeof(MDBX_stat));
+    cnt = stat.ms_entries;
+    mdbxs_abort_txn(txn);
+
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_FILE_NOT_FOUND_ERROR, "failed to stat dbi, error: %i", res);
+    }
+    return cnt;
+}
+
+static void mdbxs_each(FrtStore *store, void (*func)(const char *fname, void *arg), void *arg) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_cursor *cursor = NULL;
+
+    MDBX_val key, val;
+    key.iov_base = NULL;
+    key.iov_len  = 0;
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_open_cursor(txn, dbi, &cursor);
+
+    int op = MDBX_FIRST;
+    while(mdbx_cursor_get(cursor, &key, &val, op) == MDBX_SUCCESS) {
+        op = MDBX_NEXT;
+        func(key.iov_base, arg);
+    }
+    mdbxs_commit_txn(txn);
+}
+
+static void mdbxs_clear_locks(FrtStore *store) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_cursor *cursor = NULL;
+
+    MDBX_val key, val;
+    key.iov_base = NULL;
+    key.iov_len  = 0;
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_open_cursor(txn, dbi, &cursor);
+
+    int op = MDBX_FIRST;
+    while(mdbx_cursor_get(cursor, &key, &val, op) == MDBX_SUCCESS) {
+        op = MDBX_NEXT;
+        mdbx_cursor_del(cursor, MDBX_ALLDUPS);
+    }
+    mdbxs_commit_txn(txn);
+}
+
+static bool mdbxs_is_locked(FrtStore *store, MDBX_val *key, MDBX_txn *txn, MDBX_dbi dbi) {
+    MDBX_val val;
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    if (mdbx_get(txn, dbi, key, &val) == MDBX_SUCCESS) {
+        return true;
+    }
+
+    return false;
+}
+
+static void mdbxs_clear(FrtStore *store) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_cursor *cursor = NULL;
+
+    MDBX_val key, val;
+    key.iov_base = NULL;
+    key.iov_len  = 0;
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_open_cursor(txn, dbi, &cursor);
+
+    int op = MDBX_FIRST;
+    while(mdbx_cursor_get(cursor, &key, &val, op) == MDBX_SUCCESS) {
+        op = MDBX_NEXT;
+        if (!mdbxs_is_locked(store, &key, txn, dbi)) {
+            mdbx_cursor_del(cursor, MDBX_ALLDUPS);
+        }
+    }
+    mdbxs_commit_txn(txn);
+}
+
+/**
+ * Clear all files which belong to the index. Use mdbxs_clear to clear the
+ * directory regardless of the files origin.
+ */
+static void mdbxs_clear_all(FrtStore *store) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_cursor *cursor = NULL;
+
+    MDBX_val key, val;
+    key.iov_base = NULL;
+    key.iov_len  = 0;
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_open_cursor(txn, dbi, &cursor);
+
+    int op = MDBX_FIRST;
+    while(mdbx_cursor_get(cursor, &key, &val, op) == MDBX_SUCCESS) {
+        op = MDBX_NEXT;
+        mdbx_cursor_del(cursor, MDBX_ALLDUPS);
+    }
+    mdbxs_commit_txn(txn);
+
+    mdbxs_clear_locks(store);
+}
+
+/**
+ * Destroy the store.
+ *
+ * @param p the store to destroy
+ * @rb_raise FRT_IO_ERROR if there is an error deleting the locks
+ */
+static void mdbxs_destroy(FrtStore *store) {
+    FRT_TRY
+        if (store->dir.mdbx) {
+            mdbxs_clear_locks(store);
+            int res = mdbx_env_close(store->dir.mdbx->env);
+            if (res != MDBX_SUCCESS) {
+                fprintf(stderr, "closing env '%s' failed, error: %i\n", store->dir.mdbx->path, res);
+            }
+            free(store->dir.mdbx->path);
+            free(store->dir.mdbx);
+            store->dir.mdbx = NULL;
+        }
+    FRT_XCATCHALL
+        FRT_HANDLED();
+    FRT_XENDTRY
+}
+
+static frt_off_t mdbxs_length(FrtStore *store, const char *filename) {
+    frt_off_t len = 0;
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key, val;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_ro_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    int res = mdbx_get(txn, dbi, &key, &val);
+    if (res != MDBX_SUCCESS) {
+        mdbxs_abort_txn(txn);
+        FRT_RAISE(FRT_FILE_NOT_FOUND_ERROR, "tried to open \"%s\" but it doesn't exist, error: %i", filename, res);
+    }
+    len = val.iov_len;
+    mdbxs_abort_txn(txn);
+    return len;
+}
+
+static void mdbxso_close_i(FrtOutStream *os) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    mdbxs_begin_txn(os->store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+
+    FrtRAMFile *rf = os->file.rf;
+
+    MDBX_val key, val;
+    key.iov_base = rf->name;
+    key.iov_len  = strlen(rf->name);
+
+    val.iov_base = frt_emalloc(FRT_BUFFER_SIZE * rf->bufcnt);
+    val.iov_len  = rf->len;
+
+    int offset = 0;
+    int buffer_number, buffer_offset, bytes_in_buffer, bytes_to_copy;
+    int remainder = rf->len;
+    frt_off_t start = 0;
+    frt_uchar *buffer;
+
+    while (remainder > 0) {
+        buffer_number = (int) (start / FRT_BUFFER_SIZE);
+        buffer_offset = start % FRT_BUFFER_SIZE;
+        bytes_in_buffer = FRT_BUFFER_SIZE - buffer_offset;
+
+        if (bytes_in_buffer >= remainder) {
+            bytes_to_copy = remainder;
+        } else {
+            bytes_to_copy = bytes_in_buffer;
+        }
+        buffer = rf->buffers[buffer_number];
+        memcpy(val.iov_base + offset, buffer + buffer_offset, bytes_to_copy);
+        offset += bytes_to_copy;
+        start += bytes_to_copy;
+        remainder -= bytes_to_copy;
+    }
+
+    mdbxs_put(txn, dbi, &key, &val);
+    mdbxs_commit_txn(txn);
+    free(val.iov_base);
+    rf_close(os->file.rf);
+}
+
+static const struct FrtOutStreamMethods MDBXS_OUT_STREAM_METHODS = {
+    ramo_flush_i,
+    ramo_seek_i,
+    mdbxso_close_i
+};
+
+static FrtOutStream *mdbxs_new_output(FrtStore *store, const char *filename) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_val key, val;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    mdbxs_begin_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_put(txn, dbi, &key, &val);
+    mdbxs_commit_txn(txn);
+
+    FrtRAMFile *rf = rf_new(filename);
+    FRT_REF(rf);
+    FrtOutStream *os = frt_os_new();
+    os->pointer = 0;
+    os->file.rf = rf;
+    os->m = &MDBXS_OUT_STREAM_METHODS;
+    os->store = store;
+    return os;
+}
+
+static const struct FrtInStreamMethods RAM_IN_STREAM_METHODS = {
+    rami_read_i,
+    rami_seek_i,
+    rami_length_i,
+    rami_close_i
+};
+
+static FrtInStream *mdbxs_open_input(FrtStore *store, const char *filename) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    MDBX_val key, val;
+    key.iov_base = (char *)filename;
+    key.iov_len  = strlen(filename);
+    val.iov_base = NULL;
+    val.iov_len  = 0;
+
+    FrtRAMFile *rf = NULL;
+    FrtInStream *is;
+
+    mdbxs_begin_ro_txn(store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    if (mdbx_get(txn, dbi, &key, &val) != MDBX_SUCCESS) {
+        mdbxs_abort_txn(txn);
+        FRT_RAISE(FRT_FILE_NOT_FOUND_ERROR, "tried to open \"%s\" but it doesn't exist", filename);
+    }
+
+    rf = rf_new(filename);
+    FRT_REF(rf);
+
+    if (val.iov_len > 0) {
+        frt_uchar *buffer;
+        frt_uchar *src = val.iov_base;
+        int len = val.iov_len;
+        int buffer_number = 0;
+        int buffer_offset = 0;
+        int bytes_in_buffer = FRT_BUFFER_SIZE;
+        int bytes_to_copy = bytes_in_buffer < len ? bytes_in_buffer : len;
+        int src_offset;
+
+        rf_extend_if_necessary(rf, buffer_number);
+
+        buffer = rf->buffers[buffer_number];
+        memcpy(buffer + buffer_offset, src, bytes_to_copy);
+        src_offset = bytes_to_copy;
+
+        while (src_offset < len) {
+            bytes_to_copy = bytes_in_buffer < (len - src_offset) ? bytes_in_buffer : (len - src_offset);
+            buffer_number += 1;
+            rf_extend_if_necessary(rf, buffer_number);
+            buffer = rf->buffers[buffer_number];
+            memcpy(buffer, src + src_offset, bytes_to_copy);
+            src_offset = src_offset + bytes_to_copy;
+        }
+        rf->len = len;
+    }
+    mdbxs_abort_txn(txn);
+
+    is = frt_is_new();
+    is->f->file.rf = rf;
+    is->f->ref_cnt = 1;
+    is->d.pointer = 0;
+    is->m = &RAM_IN_STREAM_METHODS;
+
+    return is;
+}
+
+#define LOCK_OBTAIN_TIMEOUT 50
+
+static int mdbxs_lock_obtain(FrtLock *lock) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+    mdbxs_begin_txn(lock->store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+
+    MDBX_val key, val;
+    key.iov_base = lock->name;
+    key.iov_len  = strlen(lock->name);
+    int trys = LOCK_OBTAIN_TIMEOUT;
+    bool is_locked = mdbxs_is_locked(lock->store, &key, txn, dbi);
+    while (is_locked && (trys > 0)) {
+        mdbxs_abort_txn(txn);
+
+        trys--;
+        /* sleep for 10 milliseconds */
+        frt_micro_sleep(10000);
+
+        mdbxs_begin_txn(lock->store, &txn);
+        mdbxs_open_dbi(txn, dbi_name, &dbi);
+
+        is_locked = mdbxs_is_locked(lock->store, &key, txn, dbi);
+    }
+    if (is_locked) {
+        mdbxs_abort_txn(txn);
+        return false;
+    } else {
+        val.iov_base = (char *)lock_s; // could be a number to count locks
+        val.iov_len  = 4;
+        mdbxs_put(txn, dbi, &key, &val);
+        mdbxs_commit_txn(txn);
+        return true;
+    }
+}
+
+static int mdbxs_lock_is_locked(FrtLock *lock) {
+    int res = 0;
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key;
+    key.iov_base = lock->name;
+    key.iov_len  = strlen(lock->name);
+
+    mdbxs_begin_ro_txn(lock->store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    res = mdbxs_is_locked(lock->store, &key, txn, dbi);
+    mdbxs_abort_txn(txn);
+
+    return res;
+}
+
+static void mdbxs_lock_release(FrtLock *lock) {
+    MDBX_txn *txn = NULL;
+    MDBX_dbi dbi;
+
+    MDBX_val key;
+    key.iov_base = lock->name;
+    key.iov_len  = strlen(lock->name);
+
+    mdbxs_begin_txn(lock->store, &txn);
+    mdbxs_open_dbi(txn, dbi_name, &dbi);
+    mdbxs_del(txn, dbi, &key, NULL);
+    mdbxs_commit_txn(txn);
+}
+
+static FrtLock *mdbxs_open_lock_i(FrtStore *store, const char *lockname) {
+    FrtLock *lock = FRT_ALLOC(FrtLock);
+    char lname[100];
+    snprintf(lname, 100, "%s%s.lck", FRT_LOCK_PREFIX, lockname);
+    lock->name = frt_estrdup(lname);
+    lock->store = store;
+    FRT_REF(store);
+    lock->obtain = &mdbxs_lock_obtain;
+    lock->release = &mdbxs_lock_release;
+    lock->is_locked = &mdbxs_lock_is_locked;
+    lock->rlock = Qnil;
+    return lock;
+}
+
+static void mdbxs_close_lock_i(FrtLock *lock) {
+    mdbxs_lock_release(lock);
+    frt_store_close(lock->store);
+    free(lock->name);
+    free(lock);
+}
+
+static FrtHash *mdbx_stores = NULL;
+
+static pthread_mutex_t mdbx_stores_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void mdbxs_close_i(FrtStore *store) {
+    pthread_mutex_lock(&mdbx_stores_mutex);
+    if (store->dir.mdbx) {
+        frt_h_del(mdbx_stores, store->dir.mdbx->path);
+    }
+    pthread_mutex_unlock(&mdbx_stores_mutex);
+}
+
+static FrtStore *mdbx_store_new(const char *pathname) {
+    FrtStore *new_store = frt_store_new();
+
+    new_store->file_mode = S_IRUSR | S_IWUSR;
+#if !defined POSH_OS_WIN32 && !defined POSH_OS_WIN64
+    struct stat stt;
+    if (!stat(pathname, &stt)) {
+        gid_t st_gid = stt.st_gid;
+        bool is_grp = (st_gid == getgid());
+
+        if (!is_grp) {
+            int size = getgroups(0, NULL);
+            gid_t list[size];
+
+            if (getgroups(size, list) != -1) {
+                int i = 0;
+                while (i < size && !(is_grp = (st_gid == list[i]))) i++;
+            }
+        }
+
+        if (is_grp) {
+            if (stt.st_mode & S_IWGRP) {
+                umask(S_IWOTH);
+            }
+            new_store->file_mode |= stt.st_mode & (S_IRGRP | S_IWGRP);
+        }
+    }
+#endif
+
+    MDBX_env *env = NULL;
+    int res;
+    res = mdbx_env_create(&env);
+    if (res != MDBX_SUCCESS) {
+        FRT_RAISE(FRT_IO_ERROR, "creating env '%s' failed, error: %i\n", pathname, res);
+    }
+    res = mdbx_env_set_maxdbs(env, 2);
+    if (res != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        FRT_RAISE(FRT_IO_ERROR, "setting maxdbs for '%s' failed, error: %i\n", pathname, res);
+    }
+    res = mdbx_env_set_geometry(env, -1, -1, 40000000000, 4*1024*1024, 4*1024*1024, MDBX_MAX_PAGESIZE);
+    if (res != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        FRT_RAISE(FRT_IO_ERROR, "setting geometrye for '%s' failed, error: %i\n", pathname, res);
+    }
+    res = mdbx_env_open(env, pathname, MDBX_ENV_DEFAULTS, new_store->file_mode);
+    if (res != MDBX_SUCCESS) {
+        mdbx_env_close(env);
+        if (res > 0) {
+            FRT_RAISE(FRT_IO_ERROR, "opening env '%s' failed, error: %s\n", pathname, strerror(res));
+        } else {
+            FRT_RAISE(FRT_IO_ERROR, "opening env '%s' failed, error: %i\n", pathname, res);
+        }
+    }
+    MDBXInfo *mdbx = FRT_ALLOC(MDBXInfo);
+    mdbx->env = env;
+    mdbx->path = frt_estrdup(pathname);
+
+    new_store->dir.mdbx     = mdbx;
+    new_store->touch        = &mdbxs_touch;
+    new_store->exists       = &mdbxs_exists;
+    new_store->remove       = &mdbxs_remove;
+    new_store->rename       = &mdbxs_rename;
+    new_store->count        = &mdbxs_count;
+    new_store->close_i      = &mdbxs_close_i;
+    new_store->clear        = &mdbxs_clear;
+    new_store->clear_all    = &mdbxs_clear_all;
+    new_store->clear_locks  = &mdbxs_clear_locks;
+    new_store->length       = &mdbxs_length;
+    new_store->each         = &mdbxs_each;
+    new_store->new_output   = &mdbxs_new_output;
+    new_store->open_input   = &mdbxs_open_input;
+    new_store->open_lock_i  = &mdbxs_open_lock_i;
+    new_store->close_lock_i = &mdbxs_close_lock_i;
+    return new_store;
+}
+
+FrtStore *frt_open_mdbx_store(const char *pathname) {
+    FrtStore *store = NULL;
+
+    if (!mdbx_stores) {
+        mdbx_stores = frt_h_new_str(free, (frt_free_ft)mdbxs_destroy);
+        frt_register_for_cleanup(mdbx_stores, (frt_free_ft)frt_h_destroy);
+    }
+
+    pthread_mutex_lock(&mdbx_stores_mutex);
+
+    store = (FrtStore *)frt_h_get(mdbx_stores, pathname);
+    if (store) {
+        FRT_REF(store);
+    } else {
+        store = mdbx_store_new(pathname);
+        frt_h_set(mdbx_stores, frt_estrdup(pathname), store);
+    }
+
+    pthread_mutex_unlock(&mdbx_stores_mutex);
+
+    return store;
+}

data/ext/isomorfeus_ferret_ext/frt_q_parser.c

@@ -2115,7 +2115,7 @@ static int yyerror(FrtQParser *qp, rb_encoding *encoding, char const *msg)
         if (qp->clean_str) {
             free(qp->qstr);
         }
-        frt_mutex_unlock(&qp->mutex);
+        pthread_mutex_unlock(&qp->mutex);
         snprintf(frt_xmsg_buffer, FRT_XMSG_BUFFER_SIZE,
                  "couldn't parse query ``%s''. Error message "
                  " was %s", buf, (char *)msg);
@@ -2806,7 +2806,7 @@ FrtQParser *frt_qp_init(FrtQParser *self, FrtAnalyzer *analyzer) {
     self->buf_index = 0;
     self->dynbuf = NULL;
     self->non_tokenizer = frt_non_tokenizer_new();
-    frt_mutex_init(&self->mutex, NULL);
+    pthread_mutex_init(&self->mutex, NULL);
     return self;
 }
 
@@ -2974,7 +2974,7 @@ FrtQuery *qp_parse(FrtQParser *self, char *query_string, rb_encoding *encoding)
     char *qstr;
     unsigned char *dp_start = NULL;
 
-    frt_mutex_lock(&self->mutex);
+    pthread_mutex_lock(&self->mutex);
     /* if qp->fields_top->next is not NULL we have a left over field-stack
      * object that was not popped during the last query parse */
     assert(NULL == self->fields_top->next);
@@ -3025,6 +3025,6 @@ FrtQuery *qp_parse(FrtQParser *self, char *query_string, rb_encoding *encoding)
     if (dp_start)
         free(dp_start);
 
-    frt_mutex_unlock(&self->mutex);
+    pthread_mutex_unlock(&self->mutex);
     return result;
 }