ox 2.14.27 → 2.14.29

data/ext/ox/cache.c

@@ -27,6 +27,23 @@
 // almost the Murmur hash algorithm
 #define M 0x5bd1e995
 
+// Mixed into the initial state of hash_calc(). Element and attribute names come
+// straight from the document, so without a per process seed the bucket every
+// name lands in can be precomputed offline. Written once by ox_hash_seed_init()
+// during Init_ox and only read afterwards, so the caches stay Ractor safe.
+static uint64_t hash_seed = 0;
+
+void ox_hash_seed_init(void) {
+#ifdef HAVE_RB_HASH_START
+    // Folds in the random seed Ruby uses to defend Hash against the same attack.
+    hash_seed = (uint64_t)rb_hash_start(0);
+#else
+    // String#hash is per process randomized too. It can be negative, so take it
+    // as signed and reinterpret rather than letting NUM2ULL reject it.
+    hash_seed = (uint64_t)(int64_t)NUM2LL(rb_funcall(rb_str_new_literal("ox"), rb_intern("hash"), 0));
+#endif
+}
+
 typedef struct _slot {
     struct _slot     *next;
     VALUE             val;
@@ -68,7 +85,7 @@ const rb_data_type_t ox_cache_type = {
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
     const uint8_t *end     = key + len;
     const uint8_t *endless = key + (len & 0xFFFFFFFC);
-    uint64_t       h       = (uint64_t)len;
+    uint64_t       h       = (uint64_t)len ^ hash_seed;
     uint64_t       k;
 
     while (key < endless) {
@@ -100,14 +117,19 @@ static uint64_t hash_calc(const uint8_t *key, size_t len) {
 }
 
 static void rehash(Cache c) {
-    uint64_t osize;
+    uint64_t osize = c->size;
+    Slot    *slots;
     Slot    *end;
     Slot    *sp;
 
-    osize    = c->size;
+    // Growing is only an optimization, and rehash() runs with the lock held, so
+    // on failure keep the current size rather than raising.
+    if (NULL == (slots = realloc((void *)c->slots, sizeof(Slot) * osize * 4))) {
+        return;
+    }
     c->size  = osize * 4;
     c->mask  = c->size - 1;
-    c->slots = realloc((void *)c->slots, sizeof(Slot) * c->size);
+    c->slots = slots;
     memset((Slot *)c->slots + osize, 0, sizeof(Slot) * osize * 3);
     end = (Slot *)c->slots + osize;
     for (sp = (Slot *)c->slots; sp < end; sp++) {
@@ -153,7 +175,10 @@ static VALUE ox_lockless_intern(Cache c, const char *key, size_t len, const char
     }
     rkey = c->form(key, len);
     if (NULL == (b = c->reuse)) {
-        b = calloc(1, sizeof(struct _slot));
+        if (NULL == (b = calloc(1, sizeof(struct _slot)))) {
+            // Nothing modified yet and no lock held, so raising is safe.
+            rb_memerror();
+        }
     } else {
         c->reuse = b->next;
         c->rcnt--;
@@ -215,8 +240,8 @@ static VALUE ox_locking_intern(Cache c, const char *key, size_t len, const char
         c->rcnt--;
     }
     CACHE_UNLOCK(c);
-    if (NULL == b) {
-        b = calloc(1, sizeof(struct _slot));
+    if (NULL == b && NULL == (b = calloc(1, sizeof(struct _slot)))) {
+        rb_memerror();  // the lock was released above
     }
     rkey    = c->form(key, len);
     b->hash = h;
@@ -250,6 +275,9 @@ Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), b
     Cache c     = calloc(1, sizeof(struct _cache));
     int   shift = 0;
 
+    if (NULL == c) {
+        rb_memerror();
+    }
     for (; REHASH_LIMIT < size; size /= 2, shift++) {
     }
     if (shift < MIN_SHIFT) {
@@ -260,9 +288,12 @@ Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), b
 #else
     c->mutex = rb_mutex_new();
 #endif
-    c->size  = 1 << shift;
-    c->mask  = c->size - 1;
-    c->slots = calloc(c->size, sizeof(Slot));
+    c->size = 1 << shift;
+    c->mask = c->size - 1;
+    if (NULL == (c->slots = calloc(c->size, sizeof(Slot)))) {
+        free(c);
+        rb_memerror();
+    }
     c->form  = form;
     c->xrate = 1;  // low
     c->mark  = mark;
@@ -277,16 +308,20 @@ Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), b
 void ox_cache_free(void *ptr) {
     Cache    c = (Cache)ptr;
     uint64_t i;
+    Slot     next;
+    Slot     s;
 
     for (i = 0; i < c->size; i++) {
-        Slot next;
-        Slot s;
-
         for (s = c->slots[i]; NULL != s; s = next) {
             next = s->next;
             free(s);
         }
     }
+    // ox_cache_mark retires unused slots onto the reuse list, off the buckets.
+    for (s = c->reuse; NULL != s; s = next) {
+        next = s->next;
+        free(s);
+    }
     free((void *)c->slots);
     free(c);
 }

data/ext/ox/cache.h

@@ -13,6 +13,8 @@ struct _cache;
 
 extern const rb_data_type_t ox_cache_type;
 
+extern void ox_hash_seed_init(void);
+
 extern struct _cache *ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
 extern void           ox_cache_free(void *ptr);
 extern void           ox_cache_mark(void *ptr);