tdb 0.5.0 → 0.6.1

data/ext/tdb/rbtdb.h

@@ -3,12 +3,15 @@
 #include <ruby.h>
 #include <tdb.h>
 
+unsigned int rbtdb_siphash24(TDB_DATA *key);
 unsigned int rbtdb_murmur1(TDB_DATA *key);
 unsigned int rbtdb_murmur1_aligned(TDB_DATA *key);
 unsigned int rbtdb_murmur2(TDB_DATA *key);
 unsigned int rbtdb_murmur2a(TDB_DATA *key);
 unsigned int rbtdb_murmur2_neutral(TDB_DATA *key);
 unsigned int rbtdb_murmur2_aligned(TDB_DATA *key);
+unsigned int rbtdb_murmur3a(TDB_DATA *key);
+unsigned int rbtdb_murmur3f(TDB_DATA *key);
 unsigned int rbtdb_fnv1a(TDB_DATA *key);
 unsigned int rbtdb_djb2(TDB_DATA *key);
 unsigned int rbtdb_djb3(TDB_DATA *key);
@@ -19,4 +22,5 @@ unsigned int rbtdb_jenkins_lookup3(TDB_DATA *key);
 #endif
 #define rbtdb_default 0
 
+void rbtdb_init_tdb_hash_functions(void);
 #endif /* RBTDB_H */

data/ext/tdb/siphash24.c

@@ -0,0 +1,328 @@
+#include "rbtdb.h"
+/*
+   SipHash reference C implementation
+   Trivially adapted by Eric Wong for ruby-tdb
+
+   Written in 2012 by
+   Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com>
+   Daniel J. Bernstein <djb@cr.yp.to>
+
+   To the extent possible under law, the author(s) have dedicated all copyright
+   and related and neighboring rights to this software to the public domain
+   worldwide. This software is distributed without any warranty.
+
+   You should have received a copy of the CC0 Public Domain Dedication along with
+   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+*/
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef uint64_t u64;
+typedef uint32_t u32;
+typedef uint8_t u8;
+
+#define ROTL(x,b) (u64)( ((x) << (b)) | ( (x) >> (64 - (b))) )
+
+#define U32TO8_LE(p, v)         \
+    (p)[0] = (u8)((v)      ); (p)[1] = (u8)((v) >>  8); \
+    (p)[2] = (u8)((v) >> 16); (p)[3] = (u8)((v) >> 24);
+
+#define U64TO8_LE(p, v)         \
+  U32TO8_LE((p),     (u32)((v)      ));   \
+  U32TO8_LE((p) + 4, (u32)((v) >> 32));
+
+#define U8TO64_LE(p) \
+  (((u64)((p)[0])      ) | \
+   ((u64)((p)[1]) <<  8) | \
+   ((u64)((p)[2]) << 16) | \
+   ((u64)((p)[3]) << 24) | \
+   ((u64)((p)[4]) << 32) | \
+   ((u64)((p)[5]) << 40) | \
+   ((u64)((p)[6]) << 48) | \
+   ((u64)((p)[7]) << 56))
+
+#define SIPROUND            \
+  do {              \
+    v0 += v1; v1=ROTL(v1,13); v1 ^= v0; v0=ROTL(v0,32); \
+    v2 += v3; v3=ROTL(v3,16); v3 ^= v2;     \
+    v0 += v3; v3=ROTL(v3,21); v3 ^= v0;     \
+    v2 += v1; v1=ROTL(v1,17); v1 ^= v2; v2=ROTL(v2,32); \
+  } while(0)
+
+/* SipHash-2-4 */
+static int
+crypto_auth(unsigned char *out, const unsigned char *in,
+	    size_t inlen, const unsigned char *k)
+{
+	/* "somepseudorandomlygeneratedbytes" */
+	u64 v0 = 0x736f6d6570736575ULL;
+	u64 v1 = 0x646f72616e646f6dULL;
+	u64 v2 = 0x6c7967656e657261ULL;
+	u64 v3 = 0x7465646279746573ULL;
+	u64 b;
+	u64 k0 = U8TO64_LE(k);
+	u64 k1 = U8TO64_LE(k + 8);
+	u64 m;
+	const u8 *end = in + inlen - (inlen % sizeof(u64));
+	const int left = inlen & 7;
+	b = ((u64) inlen) << 56;
+	v3 ^= k1;
+	v2 ^= k0;
+	v1 ^= k1;
+	v0 ^= k0;
+
+	for (; in != end; in += 8) {
+		m = U8TO64_LE(in);
+#ifdef DEBUG
+		printf("(%3d) v0 %08x %08x\n", (int)inlen, (u32) (v0 >> 32),
+		       (u32) v0);
+		printf("(%3d) v1 %08x %08x\n", (int)inlen, (u32) (v1 >> 32),
+		       (u32) v1);
+		printf("(%3d) v2 %08x %08x\n", (int)inlen, (u32) (v2 >> 32),
+		       (u32) v2);
+		printf("(%3d) v3 %08x %08x\n", (int)inlen, (u32) (v3 >> 32),
+		       (u32) v3);
+		printf("(%3d) compress %08x %08x\n", (int)inlen,
+		       (u32) (m >> 32), (u32) m);
+#endif
+		v3 ^= m;
+		SIPROUND;
+		SIPROUND;
+		v0 ^= m;
+	}
+
+	switch (left) {
+	case 7:
+		b |= ((u64) in[6]) << 48;
+
+	case 6:
+		b |= ((u64) in[5]) << 40;
+
+	case 5:
+		b |= ((u64) in[4]) << 32;
+
+	case 4:
+		b |= ((u64) in[3]) << 24;
+
+	case 3:
+		b |= ((u64) in[2]) << 16;
+
+	case 2:
+		b |= ((u64) in[1]) << 8;
+
+	case 1:
+		b |= ((u64) in[0]);
+		break;
+
+	case 0:
+		break;
+	}
+
+#ifdef DEBUG
+	printf("(%3d) v0 %08x %08x\n", (int)inlen, (u32) (v0 >> 32), (u32) v0);
+	printf("(%3d) v1 %08x %08x\n", (int)inlen, (u32) (v1 >> 32), (u32) v1);
+	printf("(%3d) v2 %08x %08x\n", (int)inlen, (u32) (v2 >> 32), (u32) v2);
+	printf("(%3d) v3 %08x %08x\n", (int)inlen, (u32) (v3 >> 32), (u32) v3);
+	printf("(%3d) padding   %08x %08x\n", (int)inlen, (u32) (b >> 32),
+	       (u32) b);
+#endif
+	v3 ^= b;
+	SIPROUND;
+	SIPROUND;
+	v0 ^= b;
+#ifdef DEBUG
+	printf("(%3d) v0 %08x %08x\n", (int)inlen, (u32) (v0 >> 32), (u32) v0);
+	printf("(%3d) v1 %08x %08x\n", (int)inlen, (u32) (v1 >> 32), (u32) v1);
+	printf("(%3d) v2 %08x %08x\n", (int)inlen, (u32) (v2 >> 32), (u32) v2);
+	printf("(%3d) v3 %08x %08x\n", (int)inlen, (u32) (v3 >> 32), (u32) v3);
+#endif
+	v2 ^= 0xff;
+	SIPROUND;
+	SIPROUND;
+	SIPROUND;
+	SIPROUND;
+	b = v0 ^ v1 ^ v2 ^ v3;
+	U64TO8_LE(out, b);
+	return 0;
+}
+
+/*
+   SipHash-2-4 output with
+   k = 00 01 02 ...
+   and
+   in = (empty string)
+   in = 00 (1 byte)
+   in = 00 01 (2 bytes)
+   in = 00 01 02 (3 bytes)
+   ...
+   in = 00 01 02 ... 3e (63 bytes)
+*/
+u8 vectors[64][8] = {
+	{0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72,}
+	,
+	{0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74,}
+	,
+	{0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d,}
+	,
+	{0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85,}
+	,
+	{0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf,}
+	,
+	{0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18,}
+	,
+	{0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb,}
+	,
+	{0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab,}
+	,
+	{0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93,}
+	,
+	{0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e,}
+	,
+	{0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a,}
+	,
+	{0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4,}
+	,
+	{0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75,}
+	,
+	{0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14,}
+	,
+	{0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7,}
+	,
+	{0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1,}
+	,
+	{0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f,}
+	,
+	{0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69,}
+	,
+	{0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b,}
+	,
+	{0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb,}
+	,
+	{0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe,}
+	,
+	{0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0,}
+	,
+	{0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93,}
+	,
+	{0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8,}
+	,
+	{0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8,}
+	,
+	{0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc,}
+	,
+	{0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17,}
+	,
+	{0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f,}
+	,
+	{0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde,}
+	,
+	{0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6,}
+	,
+	{0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad,}
+	,
+	{0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32,}
+	,
+	{0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71,}
+	,
+	{0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7,}
+	,
+	{0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12,}
+	,
+	{0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15,}
+	,
+	{0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31,}
+	,
+	{0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02,}
+	,
+	{0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca,}
+	,
+	{0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a,}
+	,
+	{0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e,}
+	,
+	{0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad,}
+	,
+	{0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18,}
+	,
+	{0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4,}
+	,
+	{0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9,}
+	,
+	{0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9,}
+	,
+	{0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb,}
+	,
+	{0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0,}
+	,
+	{0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6,}
+	,
+	{0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7,}
+	,
+	{0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee,}
+	,
+	{0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1,}
+	,
+	{0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a,}
+	,
+	{0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81,}
+	,
+	{0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f,}
+	,
+	{0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24,}
+	,
+	{0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7,}
+	,
+	{0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea,}
+	,
+	{0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60,}
+	,
+	{0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66,}
+	,
+	{0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c,}
+	,
+	{0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f,}
+	,
+	{0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5,}
+	,
+	{0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95,}
+};
+
+int rbtdb_siphash_test_vectors(void)
+{
+#define MAXLEN 64
+	u8 in[MAXLEN], out[8], k[16];
+	int i;
+	int ok = 1;
+
+	for (i = 0; i < 16; ++i)
+		k[i] = i;
+
+	for (i = 0; i < MAXLEN; ++i) {
+		in[i] = i;
+		crypto_auth(out, in, i, k);
+
+		if (memcmp(out, vectors[i], 8)) {
+			printf("test vector failed for %d bytes\n", i);
+			ok = 0;
+		}
+	}
+
+	return ok;
+}
+
+unsigned int rbtdb_siphash24(TDB_DATA *data)
+{
+	/* n.b.: tdb is for persistent storage, so the key must be constant */
+	static uint8_t key[] = "trivial database";
+	/* static const uint8_t check[(sizeof(key) >= 16)]; */
+	union {
+		uint32_t x32[2];
+		uint64_t x64;
+	} out;
+	unsigned char *in = data->dptr;
+	size_t len = data->dsize;
+
+	crypto_auth((unsigned char *)&out, in, len, key);
+
+	return (unsigned int)(out.x32[0] ^ out.x32[1]);
+}

data/ext/tdb/tdb.c

@@ -3,17 +3,12 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
-#ifdef HAVE_RUBY_ST_H
-#  include <ruby/st.h>
-#else
-#  include <st.h>
-#endif
 #include <pthread.h>
 
 /* this protects the global list of tdb objects maintained by libtdb */
 static pthread_mutex_t big_lock = PTHREAD_MUTEX_INITIALIZER;
 static VALUE cTDB, cERR;
-static st_table *exc_hash;
+static VALUE exc_hash;
 static VALUE hashes;
 
 /* must be a macro to prevent GC from killing converted 'val's */
@@ -26,13 +21,14 @@ static VALUE hashes;
 static void init_exc(enum TDB_ERROR ecode, const char *name)
 {
 	VALUE exc = rb_define_class_under(cERR, name, cERR);
-	st_insert(exc_hash, (st_data_t)ecode, (st_data_t)exc);
+	rb_hash_aset(exc_hash, INT2NUM(ecode), exc);
 }
 
 static void init_errors(void)
 {
 	cERR = rb_define_class_under(cTDB, "ERR", rb_eStandardError);
-	exc_hash = st_init_numtable();
+	exc_hash = rb_hash_new();
+	rb_global_variable(&exc_hash);
 
 	init_exc(TDB_ERR_CORRUPT, "CORRUPT");
 	init_exc(TDB_ERR_IO, "IO");
@@ -53,7 +49,7 @@ static void my_raise(struct tdb_context *tdb)
 {
 	enum TDB_ERROR ecode = tdb_error(tdb);
 	const char *str = tdb_errorstr(tdb);
-	VALUE exc;
+	VALUE exc = Qnil;
 
 	switch (ecode) {
 	case TDB_SUCCESS:
@@ -71,9 +67,10 @@ static void my_raise(struct tdb_context *tdb)
 #ifdef HAVE_CONST_TDB_ERR_NESTING
 	case TDB_ERR_NESTING:
 #endif /* HAVE_CONST_TDB_ERR_NESTING */
-		if (!st_lookup(exc_hash, (st_data_t)ecode, (st_data_t *)&exc))
-			rb_bug("no-existent exception: %s\n", str);
+		exc = rb_hash_aref(exc_hash, INT2NUM(ecode));
 	}
+	if (NIL_P(exc))
+		rb_bug("no-existent exception: %s\n", str);
 	rb_raise(exc, str);
 }
 
@@ -81,12 +78,15 @@ static void init_hashes(void)
 {
 #define HF(x) \
 rb_hash_aset(hashes,ID2SYM(rb_intern(#x)),ULONG2NUM((unsigned long)rbtdb_##x))
+	HF(siphash24);
 	HF(murmur1);
 	HF(murmur1_aligned);
 	HF(murmur2);
 	HF(murmur2a);
 	HF(murmur2_neutral);
 	HF(murmur2_aligned);
+	HF(murmur3a);
+	HF(murmur3f);
 	HF(fnv1a);
 	HF(djb2);
 	HF(djb3);
@@ -94,26 +94,39 @@ rb_hash_aset(hashes,ID2SYM(rb_intern(#x)),ULONG2NUM((unsigned long)rbtdb_##x))
 	HF(default);
 }
 
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
-/* (very) partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
+/* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) && \
+    defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+/*
+ * Ruby 1.9 - 2.1 (we use deprecated rb_thread_blocking_region in 2.0+
+ * because we can detect (but not use) rb_thread_blocking_region in 1.9.3
+ */
+typedef VALUE (*my_blocking_fn_t)(void*);
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+	rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),(ubf),(b))
+#elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) /* Ruby 2.2+ */
+#include <ruby/thread.h>
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+	rb_thread_call_without_gvl((fn),(a),(ubf),(b))
+#else /* Ruby 1.8 */
 #  include <rubysig.h>
-typedef VALUE rb_blocking_function_t(void *);
-static VALUE my_tbr(rb_blocking_function_t *fn, void *data)
+#  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
+typedef void rb_unblock_function_t(void *);
+typedef void * rb_blocking_function_t(void *);
+static void * WITHOUT_GVL(rb_blocking_function_t *func, void *data1,
+			rb_unblock_function_t *ubf, void *data2)
 {
-	VALUE rv;
+	void *rv;
 
 	TRAP_BEG;
-	rv = fn(data);
+	rv = func(data1);
 	TRAP_END;
 
 	return rv;
 }
-#else
-static VALUE my_tbr(rb_blocking_function_t *fn, void *data)
-{
-	return rb_thread_blocking_region(fn, data, RUBY_UBF_IO, 0);
-}
-#endif /* HAVE_RUBY_THREAD_BLOCKING_REGION */
+#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+
+#define my_tbr(fn,data) WITHOUT_GVL((void *)(fn),(data),RUBY_UBF_IO,0)
 
 static void gcfree(void *ptr)
 {
@@ -154,7 +167,7 @@ struct open_args {
 	tdb_hash_func hash_fn;
 };
 
-static VALUE nogvl_open(void *ptr)
+static void * nogvl_open(void *ptr)
 {
 	struct open_args *o = ptr;
 	struct tdb_context *tdb;
@@ -164,7 +177,7 @@ static VALUE nogvl_open(void *ptr)
 	                  o->open_flags, o->mode, o->log_ctx, o->hash_fn);
 	pthread_mutex_unlock(&big_lock);
 
-	return (VALUE)tdb;
+	return (void *)tdb;
 }
 
 static void set_args(VALUE self, struct open_args *o, VALUE opts)
@@ -260,7 +273,7 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 	if (NIL_P(path))
 		o.tdb_flags |= TDB_INTERNAL;
 	else
-		o.name = StringValuePtr(path);
+		o.name = StringValueCStr(path);
 
 	tdb = (struct tdb_context *)my_tbr(nogvl_open, &o);
 	if (!tdb) {
@@ -280,16 +293,16 @@ static VALUE init(int argc, VALUE *argv, VALUE self)
 }
 
 /* tdb_close can do a lot, including cancel transactions an munmap */
-static VALUE nogvl_close(void *ptr)
+static void * nogvl_close(void *ptr)
 {
 	struct tdb_context *tdb = ptr;
-	VALUE rv;
+	long rv;
 
 	pthread_mutex_lock(&big_lock);
-	rv = (VALUE)tdb_close(tdb);
+	rv = tdb_close(tdb);
 	pthread_mutex_unlock(&big_lock);
 
-	return rv;
+	return (void *)rv;
 }
 
 static VALUE tdbclose(VALUE self)
@@ -298,7 +311,7 @@ static VALUE tdbclose(VALUE self)
 
 	DATA_PTR(self) = NULL;
 
-	if ((int)my_tbr(nogvl_close, tdb) == -1)
+	if ((long)my_tbr(nogvl_close, tdb) == -1)
 		rb_sys_fail("tdb_close");
 
 	return Qnil;
@@ -365,14 +378,14 @@ static int fetch_parse(TDB_DATA key, TDB_DATA val, void *data)
 	return 0;
 }
 
-static VALUE nogvl_parse_record(void *ptr)
+static void * nogvl_parse_record(void *ptr)
 {
 	struct fetch_parse_args *f = ptr;
 
 	if (tdb_parse_record(f->tdb, f->as.key, fetch_parse, ptr) == -1)
-		return Qnil;
+		return (void *)Qnil;
 
-	return f->value == f->as.value ? f->value : Qnil;
+	return (void *)(f->value == f->as.value ? f->value : Qnil);
 }
 
 static VALUE fetch(int argc, VALUE *argv, VALUE self)
@@ -391,7 +404,7 @@ static VALUE fetch(int argc, VALUE *argv, VALUE self)
 	f.tdb = db(self, 1);
 	TO_TDB_DATA(f.as.key, key);
 
-	return my_tbr(nogvl_parse_record, &f);
+	return (VALUE)my_tbr(nogvl_parse_record, &f);
 }
 
 struct store_args {
@@ -401,11 +414,12 @@ struct store_args {
 	int flag;
 };
 
-static VALUE nogvl_store(void *ptr)
+static void * nogvl_store(void *ptr)
 {
 	struct store_args *s = ptr;
+	long rc = tdb_store(s->tdb, s->key, s->val, s->flag);
 
-	return (VALUE)tdb_store(s->tdb, s->key, s->val, s->flag);
+	return (void *)rc;
 }
 
 static VALUE rbtdb_store(VALUE self, VALUE key, VALUE val, int flag, int soft)
@@ -417,7 +431,7 @@ static VALUE rbtdb_store(VALUE self, VALUE key, VALUE val, int flag, int soft)
 	TO_TDB_DATA(s.val, val);
 	s.flag = flag;
 
-	if ((int)my_tbr(nogvl_store, &s) == -1) {
+	if ((long)my_tbr(nogvl_store, &s) == -1) {
 		if (soft) {
 			int ecode = tdb_error(s.tdb);
 
@@ -462,11 +476,11 @@ struct exists_args {
 	TDB_DATA key;
 };
 
-static VALUE nogvl_exists(void *ptr)
+static void * nogvl_exists(void *ptr)
 {
 	struct exists_args *e = ptr;
 
-	return tdb_exists(e->tdb, e->key) == 0 ? Qfalse : Qtrue;
+	return (void *)(tdb_exists(e->tdb, e->key) == 0 ? Qfalse : Qtrue);
 }
 
 static VALUE has_key(VALUE self, VALUE key)
@@ -476,7 +490,7 @@ static VALUE has_key(VALUE self, VALUE key)
 	e.tdb = db(self, 1);
 	TO_TDB_DATA(e.key, key);
 
-	return my_tbr(nogvl_exists, &e);
+	return (VALUE)my_tbr(nogvl_exists, &e);
 }
 
 struct traverse_args {
@@ -518,13 +532,13 @@ traverse_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA val, void *data)
 	return t->state;
 }
 
-static VALUE nogvl_traverse(void *ptr)
+static void * nogvl_traverse(void *ptr)
 {
 	struct traverse_args *t = ptr;
 
 	(void)tdb_traverse(t->tdb, traverse_fn, t);
 
-	return Qfalse;
+	return (void *)Qfalse;
 }
 
 static VALUE each(VALUE self)
@@ -545,11 +559,11 @@ struct delete_args {
 	TDB_DATA key;
 };
 
-static VALUE nogvl_delete(void *ptr)
+static void * nogvl_delete(void *ptr)
 {
 	struct delete_args *d = ptr;
 
-	return tdb_delete(d->tdb, d->key) == 0 ? Qtrue : Qfalse;
+	return (void *)(tdb_delete(d->tdb, d->key) == 0 ? Qtrue : Qfalse);
 }
 
 static VALUE nuke(VALUE self, VALUE key)
@@ -559,7 +573,7 @@ static VALUE nuke(VALUE self, VALUE key)
 	d.tdb = db(self, 1);
 	TO_TDB_DATA(d.key, key);
 
-	return my_tbr(nogvl_delete, &d);
+	return (VALUE)my_tbr(nogvl_delete, &d);
 }
 
 static VALUE aref(VALUE self, VALUE key)
@@ -580,7 +594,7 @@ static VALUE delete(int argc, VALUE *argv, VALUE self)
 static VALUE lockall(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_lockall, tdb))
+	if (my_tbr(tdb_lockall, tdb))
 		my_raise(tdb);
 
 	return Qtrue;
@@ -591,7 +605,7 @@ static VALUE trylockall(VALUE self)
 	struct tdb_context *tdb = db(self, 1);
 	void *fn = tdb_lockall_nonblock;
 
-	if ((int)my_tbr((rb_blocking_function_t *)fn, tdb)) {
+	if (my_tbr(fn, tdb)) {
 		if (tdb_error(tdb) == TDB_ERR_LOCK)
 			return Qfalse;
 		my_raise(tdb);
@@ -602,7 +616,7 @@ static VALUE trylockall(VALUE self)
 static VALUE unlockall(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_unlockall, tdb))
+	if (my_tbr(tdb_unlockall, tdb))
 		my_raise(tdb);
 	return Qtrue;
 }
@@ -610,7 +624,7 @@ static VALUE unlockall(VALUE self)
 static VALUE lockall_read(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_lockall_read, tdb))
+	if (my_tbr(tdb_lockall_read, tdb))
 		my_raise(tdb);
 	return Qtrue;
 }
@@ -619,7 +633,7 @@ static VALUE trylockall_read(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
 	void *fn = tdb_lockall_read_nonblock;
-	if ((int)my_tbr((rb_blocking_function_t *)fn, tdb)) {
+	if (my_tbr(fn, tdb)) {
 		if (tdb_error(tdb) == TDB_ERR_LOCK)
 			return Qfalse;
 		my_raise(tdb);
@@ -630,7 +644,7 @@ static VALUE trylockall_read(VALUE self)
 static VALUE unlockall_read(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_unlockall_read, tdb))
+	if (my_tbr(tdb_unlockall_read, tdb))
 		my_raise(tdb);
 	return Qtrue;
 }
@@ -638,7 +652,7 @@ static VALUE unlockall_read(VALUE self)
 static VALUE lockall_mark(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_lockall_mark, tdb))
+	if (my_tbr(tdb_lockall_mark, tdb))
 		my_raise(tdb);
 	return Qtrue;
 }
@@ -646,7 +660,8 @@ static VALUE lockall_mark(VALUE self)
 static VALUE lockall_unmark(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_lockall_unmark, tdb))
+
+	if (my_tbr(tdb_lockall_unmark, tdb))
 		my_raise(tdb);
 	return Qtrue;
 }
@@ -657,7 +672,7 @@ static VALUE lockall_unmark(VALUE self)
 static VALUE clear(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_wipe_all, tdb))
+	if (my_tbr(tdb_wipe_all, tdb))
 		my_raise(tdb);
 	return self;
 }
@@ -667,7 +682,7 @@ static VALUE clear(VALUE self)
 static VALUE repack(VALUE self)
 {
 	struct tdb_context *tdb = db(self, 1);
-	if ((int)my_tbr((rb_blocking_function_t *)tdb_repack, tdb))
+	if (my_tbr(tdb_repack, tdb))
 		my_raise(tdb);
 	return self;
 }