@ohos-ports/lmdb 2.5.3 → 2.8.5-beta.0

package/src/env.cpp

@@ -1,4 +1,5 @@
-#include "lmdb-js.h"
+    #include "lmdb-js.h"
+#include <atomic>
 #ifndef _WIN32
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -9,14 +10,22 @@ using namespace Napi;
 #define IGNORE_NOTFOUND	(1)
 
 env_tracking_t* EnvWrap::envTracking = EnvWrap::initTracking();
+thread_local std::vector<EnvWrap*>* EnvWrap::openEnvWraps = nullptr;
+thread_local js_buffers_t* EnvWrap::sharedBuffers = nullptr;
+//thread_local std::unordered_map<void*, buffer_info_t>* EnvWrap::sharedBuffers = nullptr;
+void* getSharedBuffers() {
+	return (void*) EnvWrap::sharedBuffers;
+}
 
 env_tracking_t* EnvWrap::initTracking() {
 	env_tracking_t* tracking = new env_tracking_t;
 	tracking->envsLock = new pthread_mutex_t;
 	pthread_mutex_init(tracking->envsLock, nullptr);
+	tracking->getSharedBuffers = getSharedBuffers;
 	return tracking;
 }
-thread_local std::vector<EnvWrap*>* EnvWrap::openEnvWraps = nullptr;
+static napi_ref testRef;
+static napi_env testRefEnv;
 void EnvWrap::cleanupEnvWraps(void* data) {
 	if (openEnvWraps)
 		free(openEnvWraps);
@@ -39,11 +48,12 @@ EnvWrap::EnvWrap(const CallbackInfo& info) : ObjectWrap<EnvWrap>(info) {
 	this->writeTxn = nullptr;
 	this->writeWorker = nullptr;
 	this->readTxnRenewed = false;
+    this->hasWrites = false;
 	this->writingLock = new pthread_mutex_t;
 	this->writingCond = new pthread_cond_t;
 	info.This().As<Object>().Set("address", Number::New(info.Env(), (size_t) this));
 	pthread_mutex_init(this->writingLock, nullptr);
-	pthread_cond_init(this->writingCond, nullptr);
+	cond_init(this->writingCond);
 }
 MDB_env* foundEnv;
 const int EXISTING_ENV_FOUND = 10;
@@ -77,6 +87,7 @@ int checkExistingEnvs(mdb_filehandle_t fd, MDB_env* env) {
 	envRef.inode = inode;
 	envRef.env = env;
 	envRef.count = 1;
+    envRef.hasWrites = false;
 	EnvWrap::envTracking->envs.push_back(envRef);
 	return 0;
 }
@@ -105,6 +116,10 @@ void EnvWrap::cleanupStrayTxns() {
 		tw->removeFromEnvWrap();
 	}
 }
+void EnvWrap::consolidateTxns() {
+	// sort read txns by txn id, and then abort newer ones that we can just reference older ones with.
+
+}
 
 class SyncWorker : public AsyncWorker {
   public:
@@ -123,22 +138,28 @@ class SyncWorker : public AsyncWorker {
 		napi_value result; // we use direct napi call here because node-addon-api interface with throw a fatal error if a worker thread is terminating
 		napi_call_function(Env(), Env().Undefined(), Callback().Value(), 0, {}, &result);
 	}
+	void OnError(const Error& e) {
+		napi_value result; // we use direct napi call here because node-addon-api interface with throw a fatal error if a worker thread is terminating
+		napi_value arg = e.Value();
+		napi_call_function(Env(), Env().Undefined(), Callback().Value(), 1, &arg, &result);
+	}
 
 	void Execute() {
-        #ifdef _WIN32
-        int rc = mdb_env_sync(env->env, 1);
-        #else
-        int retries = 0;
-        retry:
-        int rc = mdb_env_sync(env->env, 1);
-        if (rc == EINVAL) {
-            if (retries++ < 10) {
-                sleep(1);
-                goto retry;
-            }
-            return SetError("Invalid parameter, which is often due to more transactions than available robust locked mutexes or semaphors (see docs for more info)");
-        }
-        #endif
+		#ifdef _WIN32
+		int rc = mdb_env_sync(env->env, 1);
+		#else
+		int retries = 0;
+		retry:
+		int rc = mdb_env_sync(env->env, 1);
+#ifdef MDB_LOCK_FAILURE
+		if (rc == MDB_LOCK_FAILURE) {
+			if (retries++ < 4) {
+				sleep(1);
+				goto retry;
+			}
+		}
+#endif
+		#endif
 		if (rc != 0) {
 			SetError(mdb_strerror(rc));
 		}
@@ -160,8 +181,7 @@ class CopyWorker : public AsyncWorker {
 	void Execute() {
 		int rc = mdb_env_copy2(env, path.c_str(), flags);
 		if (rc != 0) {
-			fprintf(stderr, "Error on copy code: %u\n", rc);
-			SetError("Error on copy");
+			SetError(mdb_strerror(rc));
 		}
 	}
 
@@ -170,21 +190,22 @@ class CopyWorker : public AsyncWorker {
 	std::string path;
 	int flags;
 };
-MDB_txn* EnvWrap::getReadTxn() {
-	MDB_txn* txn = writeTxn ? writeTxn->txn : nullptr;
-	if (txn)
-		return txn;
-	txn = currentReadTxn;
-	if (readTxnRenewed)
-		return txn;
-	if (txn) {
-		if (mdb_txn_renew(txn))
-			return nullptr; // if there was an error, signal with nullptr and let error propagate with last_error 
-	} else {
-		fprintf(stderr, "No current read transaction available");
-		return nullptr;
+
+MDB_txn* EnvWrap::getReadTxn(int64_t tw_address) {
+	MDB_txn* txn;
+	if (tw_address) // explicit txn
+		txn = ((TxnWrap*)tw_address)->txn;
+	else if (writeTxn && (txn = writeTxn->txn)) {
+		return txn; // no need to renew write txn
+	} else // default to current read txn
+		txn = currentReadTxn;
+	int rc = mdb_txn_renew(txn); // always try to renew
+	if (rc) {
+		if (!txn)
+			fprintf(stderr, "No current read transaction available");
+		if (rc != EINVAL)
+			return nullptr; // if there was a real error, signal with nullptr and let error propagate with last_error
 	}
-	readTxnRenewed = true;
 	return txn;
 }
 
@@ -221,8 +242,7 @@ Napi::Value EnvWrap::open(const CallbackInfo& info) {
 	if (!keyBytesValue.IsTypedArray())
 		fprintf(stderr, "Invalid key buffer\n");
 	size_t keyBufferLength;
-	napi_get_typedarray_info(info.Env(), keyBytesValue, nullptr, &keyBufferLength, &keyBuffer, nullptr, nullptr);
-	setFlagFromValue(&jsFlags, SEPARATE_FLUSHED, "separateFlushed", false, options);
+	napi_get_buffer_info(info.Env(), keyBytesValue, &keyBuffer, &keyBufferLength);
 	String path = options.Get("path").As<String>();
 	std::string pathString = path.Utf8Value();
 	// Parse the maxDbs option
@@ -236,7 +256,7 @@ Napi::Value EnvWrap::open(const CallbackInfo& info) {
 	option = options.Get("mapSize");
 	if (option.IsNumber())
 		mapSize = option.As<Number>().Int64Value();
-	int pageSize = 4096;
+	int pageSize = 0;
 	// Parse the mapSize option
 	option = options.Get("pageSize");
 	if (option.IsNumber())
@@ -262,7 +282,7 @@ Napi::Value EnvWrap::open(const CallbackInfo& info) {
 	napiEnv = info.Env();
 	rc = openEnv(flags, jsFlags, (const char*)pathString.c_str(), (char*) keyBuffer, compression, maxDbs, maxReaders, mapSize, pageSize, encryptKey.empty() ? nullptr : (char*)encryptKey.c_str());
 	//delete[] pathBytes;
-	if (rc < 0)
+	if (rc != 0)
 		return throwLmdbError(info.Env(), rc);
 	napi_add_env_cleanup_hook(napiEnv, cleanup, this);
 	return info.Env().Undefined();
@@ -272,7 +292,9 @@ int EnvWrap::openEnv(int flags, int jsFlags, const char* path, char* keyBuffer,
 	this->keyBuffer = keyBuffer;
 	this->compression = compression;
 	this->jsFlags = jsFlags;
-
+	#ifdef MDB_OVERLAPPINGSYNC
+	MDB_metrics* metrics;
+	#endif
 	int rc;
 	rc = mdb_env_set_maxdbs(env, maxDbs);
 	if (rc) goto fail;
@@ -281,7 +303,8 @@ int EnvWrap::openEnv(int flags, int jsFlags, const char* path, char* keyBuffer,
 	rc = mdb_env_set_mapsize(env, mapSize);
 	if (rc) goto fail;
 	#ifdef MDB_RPAGE_CACHE
-	rc = mdb_env_set_pagesize(env, pageSize);
+	if (pageSize)
+	   rc = mdb_env_set_pagesize(env, pageSize);
 	if (rc) goto fail;
 	#endif
 	if ((size_t) encryptionKey > 100) {
@@ -296,15 +319,24 @@ int EnvWrap::openEnv(int flags, int jsFlags, const char* path, char* keyBuffer,
 		if (rc != 0) goto fail;
 	}
 
+	if (flags & MDB_NOLOCK) {
+		fprintf(stderr, "You chose to use MDB_NOLOCK which is not officially supported by node-lmdb. You have been warned!\n");
+	}
+	#ifdef MDB_OVERLAPPINGSYNC
 	if (flags & MDB_OVERLAPPINGSYNC) {
 		flags |= MDB_PREVSNAPSHOT;
 	}
-
-	if (flags & MDB_NOLOCK) {
-		fprintf(stderr, "You chose to use MDB_NOLOCK which is not officially supported by node-lmdb. You have been warned!\n");
+	mdb_env_set_callback(env, checkExistingEnvs);
+	trackMetrics = !!(flags & MDB_TRACK_METRICS);
+	if (trackMetrics) {
+		metrics = new MDB_metrics;
+		memset(metrics, 0, sizeof(MDB_metrics));
+		rc = mdb_env_set_userctx(env, (void*) metrics);
+		if (rc) goto fail;
 	}
-	mdb_env_set_check_fd(env, checkExistingEnvs);
+	#endif
 
+	timeTxnWaiting = 0;
 	// Set MDB_NOTLS to enable multiple read-only transactions on the same thread (in this case, the nodejs main thread)
 	flags |= MDB_NOTLS;
 	// TODO: make file attributes configurable
@@ -313,14 +345,27 @@ int EnvWrap::openEnv(int flags, int jsFlags, const char* path, char* keyBuffer,
 	rc = mdb_env_open(env, path, flags, 0664);
 
 	if (rc != 0) {
-		mdb_env_close(env);
+		#ifdef MDB_OVERLAPPINGSYNC
+		if (trackMetrics) {
+			delete metrics;
+		}
+		#endif
 		if (rc == EXISTING_ENV_FOUND) {
+			mdb_env_close(env);
 			env = foundEnv;
-		} else
+		} else {
+			this->jsFlags |= OPEN_FAILED;
+			closeEnv(true);
+			pthread_mutex_unlock(envTracking->envsLock);
 			goto fail;
+		}
 	}
 	mdb_env_get_flags(env, (unsigned int*) &flags);
-	if ((jsFlags & DELETE_ON_CLOSE) || (flags & MDB_OVERLAPPINGSYNC)) {
+	if ((jsFlags & DELETE_ON_CLOSE)
+	#ifdef MDB_OVERLAPPINGSYNC
+	 	|| (flags & MDB_OVERLAPPINGSYNC)
+	#endif
+		) {
 		if (!openEnvWraps) {
 			openEnvWraps = new std::vector<EnvWrap*>;
 			napi_add_env_cleanup_hook(napiEnv, cleanupEnvWraps, nullptr);
@@ -331,13 +376,13 @@ int EnvWrap::openEnv(int flags, int jsFlags, const char* path, char* keyBuffer,
 	return 0;
 
 	fail:
-	pthread_mutex_unlock(envTracking->envsLock);
 	env = nullptr;
 	return rc;
 }
 Napi::Value EnvWrap::getMaxKeySize(const CallbackInfo& info) {
 	return Number::New(info.Env(), mdb_env_get_maxkeysize(this->env));
 }
+
 NAPI_FUNCTION(getEnvFlags) {
 	ARGS(1)
 	GET_INT64_ARG(0);
@@ -350,9 +395,9 @@ NAPI_FUNCTION(getEnvFlags) {
 NAPI_FUNCTION(setJSFlags) {
 	ARGS(2)
 	GET_INT64_ARG(0);
-    EnvWrap* ew = (EnvWrap*) i64;
-    int64_t jsFlags;
-    napi_get_value_int64(env, args[1], &jsFlags);
+	EnvWrap* ew = (EnvWrap*) i64;
+	int64_t jsFlags;
+	napi_get_value_int64(env, args[1], &jsFlags);
 	ew->jsFlags = jsFlags;
 	RETURN_UNDEFINED;
 }
@@ -377,21 +422,200 @@ NAPI_FUNCTION(EnvWrap::onExit) {
 NAPI_FUNCTION(getEnvsPointer) {
 	napi_value returnValue;
 	napi_create_double(env, (double) (size_t) EnvWrap::envTracking, &returnValue);
+	if (!EnvWrap::sharedBuffers) {
+		EnvWrap::sharedBuffers = new js_buffers_t;
+		EnvWrap::sharedBuffers->nextId = 0;
+		pthread_mutex_init(&EnvWrap::sharedBuffers->modification_lock, nullptr);
+	}
 	return returnValue;
 }
 
 NAPI_FUNCTION(setEnvsPointer) {
 	// If another version of lmdb-js is running, switch to using its list of envs
-	ARGS(1)
+	ARGS(2)
 	GET_INT64_ARG(0);
-    env_tracking_t* adoptedTracking = (env_tracking_t*) i64;
+	env_tracking_t* adoptedTracking = (env_tracking_t*) i64;
 	// copy any existing ones over to the central one
 	adoptedTracking->envs.assign(EnvWrap::envTracking->envs.begin(), EnvWrap::envTracking->envs.end());
 	EnvWrap::envTracking = adoptedTracking;
+	js_buffers_t* adoptedBuffers = (js_buffers_t*) adoptedTracking->getSharedBuffers();
+	if (EnvWrap::sharedBuffers && adoptedBuffers != EnvWrap::sharedBuffers) {
+		free(EnvWrap::sharedBuffers);
+	}
+	EnvWrap::sharedBuffers = adoptedBuffers;
+	RETURN_UNDEFINED;
+}
+
+napi_finalize cleanupSharedExternal = [](napi_env env, void* data, void* buffer_info) {
+	// Data belongs to LMDB, we shouldn't free it here
+};
+
+napi_finalize cleanupAllocatedExternal = [](napi_env env, void* data, void* buffer_info) {
+	int32_t id = ((buffer_info_t*) buffer_info)->id;
+	pthread_mutex_lock(&EnvWrap::sharedBuffers->modification_lock);
+	for (auto bufferRef = EnvWrap::sharedBuffers->buffers.begin(); bufferRef != EnvWrap::sharedBuffers->buffers.end();) {
+		if (bufferRef->second.id == id) {
+//			fprintf(stderr, "erasing buffer on cleanpu %p\n", bufferRef->first);
+			bufferRef = EnvWrap::sharedBuffers->buffers.erase(bufferRef);
+			break;
+		}
+		bufferRef++;
+	}
+	pthread_mutex_unlock(&EnvWrap::sharedBuffers->modification_lock);
+	// We malloc'ed this data so free it
+	free(data);
+};
+
+
+NAPI_FUNCTION(getSharedBuffer) {
+	ARGS(2)
+	int32_t bufferId;
+	GET_UINT32_ARG(bufferId, 0);
+	GET_INT64_ARG(1);
+	EnvWrap* ew = (EnvWrap*) i64;
+	pthread_mutex_lock(&EnvWrap::sharedBuffers->modification_lock);
+	for (auto bufferRef = EnvWrap::sharedBuffers->buffers.begin(); bufferRef != EnvWrap::sharedBuffers->buffers.end(); bufferRef++) {
+		if (bufferRef->second.id == bufferId) {
+			char* start = bufferRef->first;
+			buffer_info_t* buffer = &bufferRef->second;
+			if (buffer->env == ew->env) {
+				//fprintf(stderr, "found exiting buffer for %u\n", bufferId);
+				napi_get_reference_value(env, buffer->ref, &returnValue);
+				pthread_mutex_unlock(&EnvWrap::sharedBuffers->modification_lock);
+				return returnValue;
+			}
+			if (buffer->env) {
+				// if for some reason it is different env that didn't get cleaned up
+				napi_value arrayBuffer;
+				napi_get_reference_value(env, buffer->ref, &arrayBuffer);
+				napi_detach_arraybuffer(env, arrayBuffer);
+				napi_delete_reference(env, buffer->ref);
+			}
+			char* end = buffer->end;
+			if (buffer->isSharedMap) // only memory mapped buffers are tied to envs
+				buffer->env = ew->env;
+			size_t size = end - start;
+            if (size > 0x100000000)
+                fprintf(stderr, "Getting invalid shared buffer size %llu from start: %llu to %end: %llu", size, start, end);
+			napi_create_external_arraybuffer(env, start, size,
+					 buffer->isSharedMap ? cleanupSharedExternal : cleanupAllocatedExternal, (void*) buffer, &returnValue);
+			int64_t result;
+			napi_create_reference(env, returnValue, 1, &buffer->ref);
+			if (buffer->isSharedMap) {
+				napi_adjust_external_memory(env, -(int64_t) size, &result);
+				napi_value true_value;
+				napi_get_boolean(env, true, &true_value);
+				napi_set_named_property(env, returnValue, "isSharedMap", true_value);
+			}
+			pthread_mutex_unlock(&EnvWrap::sharedBuffers->modification_lock);
+			return returnValue;
+		}
+	}
+	pthread_mutex_unlock(&EnvWrap::sharedBuffers->modification_lock);
+	RETURN_UNDEFINED;
+}
+NAPI_FUNCTION(setTestRef) {
+	ARGS(1)
+	napi_create_reference(env, args[0], 1, &testRef);
+	testRefEnv = env;
+	RETURN_UNDEFINED
+}
+
+NAPI_FUNCTION(getTestRef) {
+	napi_value returnValue;
+	fprintf(stderr,"trying to get refernec\n");
+	napi_get_reference_value(env, testRef, &returnValue);
+	fprintf(stderr,"got refernec\n");
+	return returnValue;
+}
+
+NAPI_FUNCTION(directWrite) {
+	ARGS(4)
+	GET_INT64_ARG(0);
+	EnvWrap* ew = (EnvWrap*) i64;
+	napi_get_value_int64(env, args[1], &i64);
+	char* target = (char*) i64;
+	napi_get_value_int64(env, args[2], &i64);
+	void* source = (void*) i64;
+	uint32_t length;
+	GET_UINT32_ARG(length, 3);
+	mdb_filehandle_t fd;
+	mdb_env_get_fd(ew->env, &fd);
+	MDB_envinfo stat;
+	mdb_env_info(ew->env, &stat);
+	int64_t offset = target - (char*) stat.me_mapaddr;
+	if (offset > 0 && offset < (int64_t) stat.me_mapsize) {
+		#ifdef _WIN32
+		OVERLAPPED ov;
+		ov.Offset = offset;
+		ov.OffsetHigh = 0;
+		WriteFile(fd, source, length, nullptr, &ov);
+		#else
+		pwrite(fd, source, length, offset);
+		#endif
+	}
 	RETURN_UNDEFINED;
 }
 
-void EnvWrap::closeEnv() {
+int32_t EnvWrap::toSharedBuffer(MDB_env* env, uint32_t* keyBuffer,  MDB_val data) {
+	unsigned int flags;
+	mdb_env_get_flags(env, (unsigned int*) &flags);
+	#ifdef MDB_RPAGE_CACHE
+	if (flags & MDB_REMAP_CHUNKS) {
+		*((uint32_t*)keyBuffer) = data.mv_size;
+		*((uint32_t*) (keyBuffer + 4)) = 0;
+		return -30000;
+	}
+	#endif
+	MDB_envinfo stat;
+	mdb_env_info(env, &stat);
+	size_t mapAddress = (size_t) (char*) stat.me_mapaddr;
+	size_t dataAddress = (size_t) (char*) data.mv_data;
+    size_t bufferStart;
+    uint64_t end;
+    if (dataAddress > mapAddress && (dataAddress + data.mv_size) <= (mapAddress + stat.me_mapsize)) {
+        // an address within the memory map
+        int64_t mapOffset = dataAddress - mapAddress;
+        size_t bufferPosition = (mapOffset + (mapOffset >> 4)) >> 32;
+        bufferStart = bufferPosition << 32;
+        bufferStart += mapAddress - (bufferStart >> 4);
+        end = bufferStart + 0xffffffffll;
+        if (end > mapAddress + stat.me_mapsize)
+            end = mapAddress + stat.me_mapsize;
+    } else {
+        // outside the memory map, usually because this is from the heap during a write txn or the mmap has been reallocated
+        bufferStart = (dataAddress >> 32) << 32;
+		if (!bufferStart) // can't use a memory address of 0 because it is considered a nullptr
+			bufferStart = 8;
+        end = bufferStart + 0xffffffffll;
+    }
+    if ((dataAddress + data.mv_size) > end) {
+        // crosses boundaries, create one-off for this address
+        bufferStart = dataAddress;
+        end = bufferStart + 0xffffffffll;
+    }
+	//fprintf(stderr, "mapAddress %p bufferStart %p", mapAddress, bufferStart);
+	pthread_mutex_lock(&sharedBuffers->modification_lock);
+	auto bufferSearch = sharedBuffers->buffers.find((char*)bufferStart);
+	size_t offset = dataAddress - bufferStart;
+	buffer_info_t bufferInfo;
+	if (bufferSearch == sharedBuffers->buffers.end()) {
+        bufferInfo.end = (char*) end;
+        bufferInfo.env = nullptr;
+		bufferInfo.isSharedMap = true;
+        bufferInfo.id = sharedBuffers->nextId++;
+        sharedBuffers->buffers.emplace((char*)bufferStart, bufferInfo);
+	} else {
+		bufferInfo = bufferSearch->second;
+	}
+	pthread_mutex_unlock(&sharedBuffers->modification_lock);
+	*keyBuffer = data.mv_size;
+	*(keyBuffer + 1) = bufferInfo.id;
+	*(keyBuffer + 2) = offset;
+	return -30001;
+}
+
+void EnvWrap::closeEnv(bool hasLock) {
 	if (!env)
 		return;
 	if (openEnvWraps) {
@@ -405,21 +629,44 @@ void EnvWrap::closeEnv() {
 	}
 	napi_remove_env_cleanup_hook(napiEnv, cleanup, this);
 	cleanupStrayTxns();
-	pthread_mutex_lock(envTracking->envsLock);
+	if (!hasLock)
+		pthread_mutex_lock(envTracking->envsLock);
 	for (auto envPath = envTracking->envs.begin(); envPath != envTracking->envs.end(); ) {
 		if (envPath->env == env) {
 			envPath->count--;
+            if (hasWrites)
+                envPath->hasWrites = true;
 			if (envPath->count <= 0) {
 				// last thread using it, we can really close it now
 				unsigned int envFlags; // This is primarily useful for detecting termination of threads and sync'ing on their termination
 				mdb_env_get_flags(env, &envFlags);
-				if (envFlags & MDB_OVERLAPPINGSYNC) {
+				#ifdef MDB_OVERLAPPINGSYNC
+				if ((envFlags & MDB_OVERLAPPINGSYNC) && envPath->hasWrites) {
 					mdb_env_sync(env, 1);
 				}
+				if (envFlags & MDB_TRACK_METRICS) {
+					delete (MDB_metrics*) mdb_env_get_userctx(env);
+				}
+				#endif
 				char* path;
 				mdb_env_get_path(env, (const char**)&path);
 				path = strdup(path);
 				mdb_env_close(env);
+				pthread_mutex_lock(&sharedBuffers->modification_lock);
+				for (auto bufferRef = EnvWrap::sharedBuffers->buffers.begin(); bufferRef != EnvWrap::sharedBuffers->buffers.end();) {
+					if (bufferRef->second.env == env) {
+						napi_value arrayBuffer;
+						napi_get_reference_value(napiEnv, bufferRef->second.ref, &arrayBuffer);
+						napi_detach_arraybuffer(napiEnv, arrayBuffer);
+						napi_delete_reference(napiEnv, bufferRef->second.ref);
+						int64_t result;
+						if (bufferRef->second.id >= 0)
+							napi_adjust_external_memory(napiEnv, bufferRef->second.end - bufferRef->first, &result);
+						bufferRef = EnvWrap::sharedBuffers->buffers.erase(bufferRef);
+					} else
+						bufferRef++;
+				}
+				pthread_mutex_unlock(&sharedBuffers->modification_lock);
 				if (jsFlags & DELETE_ON_CLOSE) {
 					unlink(path);
 					//unlink(strcat(envPath->path, "-lock"));
@@ -430,7 +677,8 @@ void EnvWrap::closeEnv() {
 		}
 		++envPath;
 	}
-	pthread_mutex_unlock(envTracking->envsLock);
+	if (!hasLock)
+		pthread_mutex_unlock(envTracking->envsLock);
 	env = nullptr;
 }
 
@@ -469,9 +717,8 @@ Napi::Value EnvWrap::freeStat(const CallbackInfo& info) {
 	}
 	int rc;
 	MDB_stat stat;
-	TxnWrap *txn;
-	napi_unwrap(info.Env(), info[0], (void**)&txn);
-	rc = mdb_stat(txn->txn, 0, &stat);
+	MDB_txn *txn = getReadTxn();
+	rc = mdb_stat(txn, 0, &stat);
 	if (rc != 0) {
 		return throwLmdbError(info.Env(), rc);
 	}
@@ -502,6 +749,22 @@ Napi::Value EnvWrap::info(const CallbackInfo& info) {
 	stats.Set("lastTxnId", Number::New(info.Env(), envinfo.me_last_txnid));
 	stats.Set("maxReaders", Number::New(info.Env(), envinfo.me_maxreaders));
 	stats.Set("numReaders", Number::New(info.Env(), envinfo.me_numreaders));
+	#ifdef MDB_OVERLAPPINGSYNC
+	if (this->trackMetrics) {
+		MDB_metrics* metrics = (MDB_metrics*) mdb_env_get_userctx(this->env);
+		stats.Set("timeStartTxns", Number::New(info.Env(), (double) metrics->time_start_txns / TICKS_PER_SECOND));
+		stats.Set("timeDuringTxns", Number::New(info.Env(), (double) metrics->time_during_txns / TICKS_PER_SECOND));
+		stats.Set("timePageFlushes", Number::New(info.Env(), (double) metrics->time_page_flushes / TICKS_PER_SECOND));
+		stats.Set("timeSync", Number::New(info.Env(), (double) metrics->time_sync / TICKS_PER_SECOND));
+		stats.Set("timeTxnWaiting", Number::New(info.Env(), (double) timeTxnWaiting / TICKS_PER_SECOND));
+		stats.Set("txns", Number::New(info.Env(), metrics->txns));
+		stats.Set("pageFlushes", Number::New(info.Env(), metrics->page_flushes));
+		stats.Set("pagesWritten", Number::New(info.Env(), metrics->pages_written));
+		stats.Set("writes", Number::New(info.Env(), metrics->writes));
+		stats.Set("puts", Number::New(info.Env(), metrics->puts));
+		stats.Set("deletes", Number::New(info.Env(), metrics->deletes));
+	}
+	#endif
 	return stats;
 }
 
@@ -627,9 +890,16 @@ Napi::Value EnvWrap::commitTxn(const CallbackInfo& info) {
 			pthread_mutex_unlock(this->writingLock);
 	}
 	delete currentTxn;
-	if (rc)
-		throwLmdbError(info.Env(), rc);
-	return info.Env().Undefined();
+    if (rc == 0) {
+        hasWrites = true;
+        return Napi::Boolean::New(info.Env(), true);
+    }
+#ifdef MDB_EMPTY_TXN
+	else if (rc == MDB_EMPTY_TXN)
+        return Napi::Boolean::New(info.Env(), false);
+#endif
+    else
+        return throwLmdbError(info.Env(), rc);
 }
 Napi::Value EnvWrap::abortTxn(const CallbackInfo& info) {
 	TxnTracked *currentTxn = this->writeTxn;
@@ -687,11 +957,6 @@ Napi::Value EnvWrap::sync(const CallbackInfo& info) {
 	return info.Env().Undefined();
 }
 
-Napi::Value EnvWrap::resetCurrentReadTxn(const CallbackInfo& info) {
-	mdb_txn_reset(this->currentReadTxn);
-	this->readTxnRenewed = false;
-	return info.Env().Undefined();
-}
 int32_t writeFFI(double ewPointer, uint64_t instructionAddress) {
 	EnvWrap* ew = (EnvWrap*) (size_t) ewPointer;
 	int rc;
@@ -715,6 +980,7 @@ void EnvWrap::setupExports(Napi::Env env, Object exports) {
 		EnvWrap::InstanceMethod("commitTxn", &EnvWrap::commitTxn),
 		EnvWrap::InstanceMethod("abortTxn", &EnvWrap::abortTxn),
 		EnvWrap::InstanceMethod("sync", &EnvWrap::sync),
+		EnvWrap::InstanceMethod("resumeWriting", &EnvWrap::resumeWriting),
 		EnvWrap::InstanceMethod("startWriting", &EnvWrap::startWriting),
 		EnvWrap::InstanceMethod("stat", &EnvWrap::stat),
 		EnvWrap::InstanceMethod("freeStat", &EnvWrap::freeStat),
@@ -723,7 +989,6 @@ void EnvWrap::setupExports(Napi::Env env, Object exports) {
 		EnvWrap::InstanceMethod("readerList", &EnvWrap::readerList),
 		EnvWrap::InstanceMethod("copy", &EnvWrap::copy),
 		//EnvWrap::InstanceMethod("detachBuffer", &EnvWrap::detachBuffer),
-		EnvWrap::InstanceMethod("resetCurrentReadTxn", &EnvWrap::resetCurrentReadTxn),
 	});
 	EXPORT_NAPI_FUNCTION("compress", compress);
 	EXPORT_NAPI_FUNCTION("write", write);
@@ -732,6 +997,9 @@ void EnvWrap::setupExports(Napi::Env env, Object exports) {
 	EXPORT_NAPI_FUNCTION("setEnvsPointer", setEnvsPointer);
 	EXPORT_NAPI_FUNCTION("getEnvFlags", getEnvFlags);
 	EXPORT_NAPI_FUNCTION("setJSFlags", setJSFlags);
+	EXPORT_NAPI_FUNCTION("getSharedBuffer", getSharedBuffer);
+	EXPORT_NAPI_FUNCTION("setTestRef", setTestRef);
+	EXPORT_NAPI_FUNCTION("getTestRef", getTestRef);
 	EXPORT_FUNCTION_ADDRESS("writePtr", writeFFI);
 	//envTpl->InstanceTemplate()->SetInternalFieldCount(1);
 	exports.Set("Env", EnvClass);