teptris 0.2.52-s390x-linux → 0.2.53-s390x-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea1037536fce2900370ed6d467638588b433c8f9fe50a26eff5fb7ea0e2affdc
-  data.tar.gz: 4027f1e1abe2e032f617faf7494bb2cba5f573f27f23f34436df6b0aacaab108
+  metadata.gz: 695435332d5909641a7303590f395aec50dc7d1be4cf8607df890d57c10699c1
+  data.tar.gz: 67bf3136a82d9e467d63687c5e93e640b76870162e39985e4dec7a578be53d30
 SHA512:
-  metadata.gz: e0c7beecfb8a2c7d12a2305c97a8472b1391dcc7e37e4deb13470d8da19ac27e229d4a62305d42d345087cf0cf7e7da09c1baf9b1e099113d636dd172e161d2c
-  data.tar.gz: 5252cc87f461a061d26d88dac81d6cc32c9fcb0b4f152f0aa42acc332eae65fe15cda7575558fd58a452cbc575c30e218f1856d1898ccbd6b9d554138e89913e
+  metadata.gz: 76d4adb38e94cd445ec22805859074c273a2371374e142a119343cb4212828636b27a5e44cb622fa53c6abf522d95460fd5112871934aef04dea920661a3d5b6
+  data.tar.gz: 5f77a3e4c1a3e418f6287d0b29f8aa43796b94be29ffd332f4d5986a5af079dfd389bba2e4bafb364f359aba90da195afe9bb95dd889c36afd0ac12ea77785f6

data/ext/teptris_ext/materialize.c

@@ -256,28 +256,6 @@ static void *parse_without_gvl(void *p)
     return NULL;
 }
 
-static teptris_document *parse_or_raise(VALUE str) {
-    teptris_document *doc = NULL;
-    /* frozen strings cannot take the tmp lock (ruby 4.0 raises
-     * FrozenError - chilled literals); a dup is movable-page-safe the
-     * same way, at one input copy for frozen callers only */
-    volatile VALUE pin = OBJ_FROZEN(str) ? rb_str_dup(str) : str;
-    rb_str_locktmp(pin);
-    struct gvl_parse_arg arg = {RSTRING_PTR(pin), (size_t)RSTRING_LEN(pin),
-                                &doc, TEPTRIS_OK};
-    rb_thread_call_without_gvl(parse_without_gvl, &arg, RUBY_UBF_IO, NULL);
-    rb_str_unlocktmp(pin);
-    teptris_status st = arg.st;
-    if (st != TEPTRIS_OK) {
-        const teptris_error *e = teptris_document_error(doc);
-        VALUE ex = rb_exc_new(eParseError, e->message, (long)strlen(e->message));
-        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
-        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
-        teptris_document_free(doc);
-        rb_exc_raise(ex);
-    }
-    return doc;
-}
 
 static VALUE ext_load(int argc, VALUE *argv, VALUE self) {
     VALUE str, opts;
@@ -292,11 +270,29 @@ static VALUE ext_load(int argc, VALUE *argv, VALUE self) {
         if (RTEST(ft)) flags |= FMT_FORBID_TIME;
         if (RTEST(fd)) flags |= FMT_FORBID_DATE;
     }
-    teptris_document *doc = parse_or_raise(str);
+    /* the parse is pure C over a private copy, GVL-free; the copy
+     * must outlive materialization - the document's strings are
+     * zero-copy views into it (a real UAF on glibc when freed early) */
+    long len = RSTRING_LEN(str);
+    char *cbuf = ALLOC_N(char, (size_t)len + 1);
+    memcpy(cbuf, RSTRING_PTR(str), (size_t)len);
+    teptris_document *doc = NULL;
+    struct gvl_parse_arg arg = {cbuf, (size_t)len, &doc, TEPTRIS_OK};
+    rb_thread_call_without_gvl(parse_without_gvl, &arg, RUBY_UBF_IO, NULL);
+    if (arg.st != TEPTRIS_OK) {
+        const teptris_error *e = teptris_document_error(doc);
+        VALUE ex = rb_exc_new(eParseError, e->message, (long)strlen(e->message));
+        rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+        rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+        xfree(cbuf);
+        teptris_document_free(doc);
+        rb_exc_raise(ex);
+    }
     keycache kc;
     kc_init(&kc);
     VALUE out = obj_from_node(teptris_document_root(doc), flags, &kc);
     kc_free(&kc);
+    xfree(cbuf);
     teptris_document_free(doc);
     return out;
 }
@@ -741,7 +737,8 @@ static VALUE cLazyOwner, cLazyValue;
 
 typedef struct {
     teptris_document *doc;
-    VALUE input; /* the borrowed views' buffer */
+    VALUE input; /* single-doc path: owned frozen copy (GC-marked) */
+    char *buf;   /* batch path: owned input copy the doc's views use */
 } lazy_owner;
 
 typedef struct {
@@ -752,12 +749,18 @@ typedef struct {
 static void lazy_owner_free(void *p) {
     lazy_owner *o = (lazy_owner *)p;
     if (o->doc != NULL) teptris_document_free(o->doc);
+    if (o->buf != NULL) xfree(o->buf);
     xfree(o);
 }
 static size_t lazy_owner_size(const void *p) { return sizeof(lazy_owner); }
+static void lazy_owner_mark(void *p)
+{
+    lazy_owner *o = (lazy_owner *)p;
+    if (o->input) rb_gc_mark(o->input); /* roots the single-path copy */
+}
 static const rb_data_type_t lazy_owner_type = {
     "TeptrisExt/LazyOwner",
-    {NULL, lazy_owner_free, lazy_owner_size, NULL, 0},
+    {lazy_owner_mark, lazy_owner_free, lazy_owner_size, NULL, 0},
     NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY};
 
 static void lazy_value_mark(void *p) {
@@ -792,7 +795,7 @@ static VALUE ext_load_lazy(VALUE self, VALUE toml) {
     VALUE owner = TypedData_Make_Struct(cLazyOwner, lazy_owner,
                                         &lazy_owner_type, o);
     o->doc = NULL;
-    o->input = rb_str_new_frozen(toml); /* borrowed views: own a copy */
+    o->input = rb_str_new_frozen(toml); /* owned frozen copy */
     teptris_status st = teptris_parse(RSTRING_PTR(o->input),
                                       (size_t)RSTRING_LEN(o->input),
                                       NULL, &o->doc);
@@ -973,25 +976,53 @@ static unsigned flags_from_opts(VALUE opts) {
 /* Parse-only batch (returns an Array of Lazy wrappers, one per doc):
  * eager parse, deferred materialization. Same per-doc error semantics
  * as ext_load_lazy. */
+struct batch_parse_arg {
+    const char **data;
+    size_t *lens;
+    size_t n;
+    teptris_document **docs;
+    teptris_status *statuses;
+    teptris_status batch;
+};
+
+static void *batch_parse_without_gvl(void *p)
+{
+    struct batch_parse_arg *a = (struct batch_parse_arg *)p;
+    a->batch = teptris_parse_batch(a->data, a->lens, a->n, NULL,
+                                   a->docs, a->statuses);
+    return NULL;
+}
+
 static VALUE ext_load_lazy_batch(VALUE self, VALUE strings) {
     Check_Type(strings, T_ARRAY);
     long n = RARRAY_LEN(strings);
     if (n == 0) return rb_ary_new();
     batch_scratch *s = batch_scratch_alloc(n);
     if (s == NULL) rb_raise(eError, "out of memory batching %ld documents", n);
+    /* the batch parse is pure C: pin every input (one tmp lock per
+     * string - repeated objects dup; frozen strings cannot take the
+     * lock, yet compaction can move them) and release the GVL for the
+     * whole parse */
+    /* the batch parse is pure C over private copies: a Ruby-string
+     * buffer can move under a concurrent compacting GC, and locktmp
+     * does not pin on every platform - copies are C memory, immovable
+     * by construction. Each LazyOwner owns its copy (freed with the
+     * owner): the lazy nodes view these buffers until materialized. */
+    char **bufs = ALLOC_N(char *, n);
     for (long i = 0; i < n; i++) {
         VALUE str = rb_ary_entry(strings, i);
         StringValue(str); /* raises TypeError if not coercible */
-        s->data[i] = RSTRING_PTR(str);
-        s->lens[i] = (size_t)RSTRING_LEN(str);
-    }
-    teptris_status batch =
-        teptris_parse_batch(s->data, s->lens, (size_t)n, NULL,
-                            s->docs, s->statuses);
-    if (batch != TEPTRIS_OK) {
-        batch_scratch_free(s);
-        rb_raise(eError, "batch parse failed (status %d)", (int)batch);
+        long len = RSTRING_LEN(str);
+        bufs[i] = ALLOC_N(char, (size_t)len + 1);
+        memcpy(bufs[i], RSTRING_PTR(str), (size_t)len);
+        s->data[i] = bufs[i];
+        s->lens[i] = (size_t)len;
     }
+    struct batch_parse_arg arg = {s->data, s->lens, (size_t)n,
+                                  s->docs, s->statuses, TEPTRIS_OK};
+    rb_thread_call_without_gvl(batch_parse_without_gvl, &arg,
+                               RUBY_UBF_IO, NULL);
+    teptris_status batch = arg.batch;
     long first_fail = -1;
     for (long i = 0; i < n; i++) {
         if (s->statuses[i] != TEPTRIS_OK && first_fail == -1) first_fail = i;
@@ -1012,7 +1043,7 @@ static VALUE ext_load_lazy_batch(VALUE self, VALUE strings) {
         VALUE owner = TypedData_Make_Struct(cLazyOwner, lazy_owner,
                                             &lazy_owner_type, o);
         o->doc = s->docs[i];
-        o->input = rb_ary_entry(strings, i);
+        o->buf = bufs[i]; /* the owner owns this copy */
         rb_ary_push(out, lazy_wrap(owner, teptris_document_root(s->docs[i])));
     }
     batch_scratch_free(s);
@@ -1053,35 +1084,29 @@ static VALUE ext_load_slice(int argc, VALUE *argv, VALUE self) {
     if (n == 0) return rb_ary_new();
     unsigned flags = flags_from_opts(opts);
 
-    volatile VALUE *pins = ALLOC_N(VALUE, n);
+    /* the GVL-free parse reads private copies: a Ruby-string buffer
+     * can move under a concurrent compacting GC, and locktmp does not
+     * pin on every platform (windows ruby 3.3 parsed garbage). Copies
+     * are C memory - immovable by construction. Freed after
+     * materialization (the docs view them until then). */
     const char **data = ALLOC_N(const char *, n);
     size_t *lens = ALLOC_N(size_t, n);
     teptris_document **docs = ALLOC_N(teptris_document *, n);
     teptris_status *stats = ALLOC_N(teptris_status, n);
-    /* the tmp lock is one-per-string: repeated objects in the slice
-     * get a dup before pinning (frozen inputs dup for the same reason
-     * - they cannot take the lock, yet compaction can move them) */
-    VALUE seen = rb_hash_new();
+    char **bufs = ALLOC_N(char *, n);
     long i;
     for (i = 0; i < n; i++) {
         VALUE str = rb_ary_entry(strs, i);
         StringValue(str);
-        VALUE id = rb_obj_id(str);
-        if (!NIL_P(rb_hash_aref(seen, id))) {
-            str = rb_str_dup(str);
-        } else {
-            rb_hash_aset(seen, id, Qtrue);
-            if (OBJ_FROZEN(str)) str = rb_str_dup(str);
-        }
-        pins[i] = str;
-        rb_str_locktmp(pins[i]);
-        data[i] = RSTRING_PTR(pins[i]);
-        lens[i] = (size_t)RSTRING_LEN(pins[i]);
+        long len = RSTRING_LEN(str);
+        bufs[i] = ALLOC_N(char, (size_t)len + 1);
+        memcpy(bufs[i], RSTRING_PTR(str), (size_t)len);
+        data[i] = bufs[i];
+        lens[i] = (size_t)len;
     }
     struct slice_parse_arg arg = {n, data, lens, docs, stats};
     rb_thread_call_without_gvl(slice_parse_without_gvl, &arg,
                                RUBY_UBF_IO, NULL);
-    for (i = 0; i < n; i++) rb_str_unlocktmp(pins[i]);
 
     VALUE out = rb_ary_new_capa(n);
     keycache kc;
@@ -1091,7 +1116,7 @@ static VALUE ext_load_slice(int argc, VALUE *argv, VALUE self) {
             const char *msg = "parse failed (out of memory)";
             VALUE ex = rb_exc_new(eParseError, msg, (long)strlen(msg));
             kc_free(&kc);
-            xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+            xfree(data); xfree(lens); xfree(docs); xfree(stats);
             rb_exc_raise(ex);
         }
         const teptris_error *e = teptris_document_error(docs[i]);
@@ -1103,7 +1128,7 @@ static VALUE ext_load_slice(int argc, VALUE *argv, VALUE self) {
             long j;
             for (j = i; j < n; j++) teptris_document_free(docs[j]);
             kc_free(&kc);
-            xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+            xfree(data); xfree(lens); xfree(docs); xfree(stats);
             rb_exc_raise(ex);
         }
     }
@@ -1113,7 +1138,7 @@ static VALUE ext_load_slice(int argc, VALUE *argv, VALUE self) {
         teptris_document_free(docs[i]);
     }
     kc_free(&kc);
-    xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+    xfree(data); xfree(lens); xfree(docs); xfree(stats);
     return out;
 }
 

data/lib/teptris/version.rb

@@ -1,3 +1,3 @@
 module Teptris
-  VERSION = "0.2.52"
+  VERSION = "0.2.53"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.52
+  version: 0.2.53
 platform: s390x-linux
 authors:
 - teptris contributors