bootsnap 1.24.6 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c89c653bbd5db473e06179c6606268271c8c540a588cca938662f168d64f2d39
-  data.tar.gz: 449c08c79a258dea90e56646c9d62a06e1d696c065ce96c38a7f50ef2fb83f7b
+  metadata.gz: 6227028d2a559d0e5129ef91915f65a064082b2e1326517dd67da2f11d91d194
+  data.tar.gz: 1c7cbf82581f9162601a7723812201d240661c0d3477373b820cf7e942b9d416
 SHA512:
-  metadata.gz: 2ea80faffec0206b9bb7b3d19c1419b2e7eefc2dc5f4eb03352862b83afa07ed293d0b15f04fc069d89dac1cd4d4636770626e90e6129ffad77f0cfcb8c3f676
-  data.tar.gz: 82dcb1a4c934a9de29a8aa935ffe2d1a7c6e23ebf36ea743c3d29a4d9a1d8bd42696cdefd37dacdd21a4102f88f0b605d1cc6faef9c15ccdc6d99eef15f4483e
+  metadata.gz: 385183b9de17b6f72634b7307fdfc5481108afc06554b48bb2dede97e51ba4275d076357934d338286fceb3a221f1468ec2ea10e2f0f869de5a7b5b97fc444a8
+  data.tar.gz: c74bb8bdfe0e6f3615bbc4a6ea4f7c5a7a1d8589a3469da964c25b44451fbb3f54f10521b8549dc6ac400d7fb17ba4a686b5b289115e8b3bac81d7a5449e3c0b

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Unreleased
 
+# 1.26.0
+
+* Handle top level `Coverage` constant being defined, but without it being the true stdlib `coverage` module.
+* Fix `bootsnap precompile` that could generate a corrupted cache entry if an already cached YAML file was modified
+  without changing its size.
+* Workaround a potential Ruby SEGV if `Bootsnap.instrumentation` raised an error.
+
+# 1.25.0
+
+* Improve YAML parsing cache to more efficiently handle `Time`, `Date` and `DateTime`.
+
+* Don't invalidate the compile cache when YJIT is toggled. YJIT is a runtime JIT and doesn't change the
+  serialized instruction sequences that are cached, but enabling it (via `--yjit`, `RUBYOPT`, or
+  `RubyVM::YJIT.enable`) adds a ` +YJIT` marker to `RUBY_DESCRIPTION` (` +YJIT <token>` on `YJIT_SUPPORT`
+  builds), which is part of the cache key. This previously discarded the entire compile cache whenever YJIT
+  was enabled at runtime but not at precompile time (or vice versa). The marker is now stripped before hashing.
+
+* Fix `CompileCache::Native.fetch` and `.precompile` reading a non-`String` path argument (e.g. a `Pathname`)
+  with `RSTRING_PTR`. Regression from 1.24.0.
+
 # 1.24.6
 
 * Fix detection of Ruby bug #22023 on some patch versions of Ruby 3.4, and properly apply the workaround.

data/ext/bootsnap/bootsnap.c

@@ -79,7 +79,7 @@ struct bs_cache_key {
 STATIC_ASSERT(sizeof(struct bs_cache_key) == KEY_SIZE);
 
 /* Effectively a schema version. Bumping invalidates all previous caches */
-static const uint32_t bootsnap_cache_version = 7;
+static const uint32_t bootsnap_cache_version = 8;
 
 /* Invalidates cache when switching ruby version, platform or ABI */
 static uint64_t base_ruby_version_digest = 0;
@@ -318,7 +318,13 @@ static inline void
 bs_instrumentation(VALUE event, VALUE path)
 {
     if (RB_UNLIKELY(instrumentation_enabled)) {
+       // If the funcall raises and rescues an error we will lose the errinfo
+       // that exists now so we save it before and restore it after.
+       VALUE saved_errinfo = rb_errinfo();
        rb_funcall(rb_mBootsnap, instrumentation_method, 2, event, path);
+       // If the ruby code in instrumentation_method raised we won't reach this point.
+       // If it didn't raise it _might_ have rescued so we should restore errinfo.
+       rb_set_errinfo(saved_errinfo);
     }
 }
 
@@ -384,7 +390,7 @@ bs_compile_option_crc32_set(VALUE self, VALUE crc32_v)
 static uint64_t
 get_ruby_version_digest(void)
 {
-  uint64_t hash = fnv1a_64_str(rb_const_get(rb_cObject, rb_intern("RUBY_DESCRIPTION")));
+  uint64_t hash = fnv1a_64_str(rb_const_get(rb_mBootsnap, rb_intern("RUBY_CACHE_KEY")));
   hash = fnv1a_64_iter(hash, (unsigned char *)&bootsnap_cache_version, sizeof(bootsnap_cache_version));
   return hash;
 }
@@ -395,12 +401,14 @@ get_ruby_version_digest(void)
  * be stored.
  *
  * The path will look something like: <cachedir>/12/34567890abcdef
+ *
+ * `path_v` must already have been through FilePathValue(): the callers read it
+ * with RSTRING_PTR() too, so the conversion has to happen in the frame that
+ * owns the variable.
  */
 static void
 bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_path)[MAX_CACHEPATH_SIZE])
 {
-  FilePathValue(path_v);
-
   Check_Type(cachedir_v, T_STRING);
   Check_Type(path_v, T_STRING);
 
@@ -454,11 +462,34 @@ static int cache_key_equal_slow_path(struct bs_cache_key *current_key,
   return current_key->digest == cached_key->digest;
 }
 
+static ssize_t
+resumable_write(int fd, const void *buf, size_t count)
+{
+  size_t total_written = 0;
+  const char *ptr = buf;
+
+  while (count > 0) {
+    ssize_t res = write(fd, ptr, count);
+
+    if (res < 0) {
+      if (errno == EINTR) {
+        continue; // Interrupted by signal, try again
+      }
+      return -1; // Real error
+    }
+
+    ptr += res;
+    count -= res;
+    total_written += res;
+  }
+  return total_written;
+}
+
 static int update_cache_key(struct bs_cache_key *current_key, struct bs_cache_key *old_key, int cache_fd, const char ** errno_provenance)
 {
   old_key->mtime = current_key->mtime;
   lseek(cache_fd, 0, SEEK_SET);
-  ssize_t nwrite = write(cache_fd, old_key, KEY_SIZE);
+  ssize_t nwrite = resumable_write(cache_fd, old_key, KEY_SIZE);
   if (nwrite < 0) {
       *errno_provenance = "update_cache_key:write";
       return -1;
@@ -492,6 +523,8 @@ static void bs_cache_key_digest(struct bs_cache_key *key,
 static VALUE
 bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler, VALUE args)
 {
+  FilePathValue(path_v);
+
   char cache_path[MAX_CACHEPATH_SIZE];
 
   /* generate cache path to cache_path */
@@ -508,6 +541,8 @@ bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE
 static VALUE
 bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler)
 {
+  FilePathValue(path_v);
+
   char cache_path[MAX_CACHEPATH_SIZE];
   /* generate cache path to cache_path */
   bs_cache_path(cachedir_v, namespace_v, path_v, &cache_path);
@@ -719,6 +754,17 @@ mkpath(char * file_path, mode_t mode)
   return 0;
 }
 
+static int
+bs_fchmod(int fd, const char *path, mode_t mode)
+{
+#ifdef _WIN32
+  setmode(fd, O_BINARY);
+  return chmod(path, mode);
+#else
+  return fchmod(fd, mode);
+#endif
+}
+
 /*
  * Write a cache header/key and a compiled artifact to a given cache path by
  * writing to a tmpfile and then renaming the tmpfile over top of the final
@@ -732,13 +778,18 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, cons
   int fd, ret, attempt;
   ssize_t nwrite;
 
+  uint64_t data_size = RSTRING_LEN(data);
+  if (data_size > (uint32_t)-1) {
+    return 0; // Don't cache.
+  }
+
   for (attempt = 0; attempt < MAX_CREATE_TEMPFILE_ATTEMPT; ++attempt) {
     tmp_path = strncpy(template, path, MAX_CACHEPATH_SIZE);
     strcat(tmp_path, ".tmp.XXXXXX");
 
     // mkstemp modifies the template to be the actual created path
     fd = mkstemp(tmp_path);
-    if (fd > 0) break;
+    if (fd >= 0) break;
 
     if (attempt == 0 && mkpath(tmp_path, 0775) < 0) {
       *errno_provenance = "bs_fetch:atomic_write_cache_file:mkpath";
@@ -750,50 +801,42 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, cons
     return -1;
   }
 
-  if (chmod(tmp_path, 0644) < 0) {
+  if (bs_fchmod(fd, tmp_path, 0644 & ~current_umask) < 0) {
+    close(fd);
     *errno_provenance = "bs_fetch:atomic_write_cache_file:chmod";
     return -1;
   }
 
-  #ifdef _WIN32
-  setmode(fd, O_BINARY);
-  #endif
-
-  uint64_t data_size = RSTRING_LEN(data);
-  if (data_size > (uint32_t)-1) {
-    return 0; // Don't cache.
-  }
-
   key->data_size = (uint32_t)data_size;
-  nwrite = write(fd, key, KEY_SIZE);
+  nwrite = resumable_write(fd, key, KEY_SIZE);
   if (nwrite < 0) {
+    close(fd);
     *errno_provenance = "bs_fetch:atomic_write_cache_file:write";
     return -1;
   }
   if (nwrite != KEY_SIZE) {
+    close(fd);
     *errno_provenance = "bs_fetch:atomic_write_cache_file:keysize";
     errno = EIO; /* Lies but whatever */
     return -1;
   }
 
-  nwrite = write(fd, RSTRING_PTR(data), RSTRING_LEN(data));
+  nwrite = resumable_write(fd, RSTRING_PTR(data), RSTRING_LEN(data));
   if (nwrite < 0) return -1;
   if (nwrite != RSTRING_LEN(data)) {
+    close(fd);
     *errno_provenance = "bs_fetch:atomic_write_cache_file:writelength";
     errno = EIO; /* Lies but whatever */
     return -1;
   }
 
   close(fd);
+
   ret = rename(tmp_path, path);
   if (ret < 0) {
     *errno_provenance = "bs_fetch:atomic_write_cache_file:rename";
     return -1;
   }
-  ret = chmod(path, 0664 & ~current_umask);
-  if (ret < 0) {
-    *errno_provenance = "bs_fetch:atomic_write_cache_file:chmod";
-  }
   return ret;
 }
 
@@ -1099,7 +1142,7 @@ bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler)
   /* Cache is stale, invalid, or missing. Regenerate and write it out. */
 
   /* Read the contents of the source file into a buffer */
-  if ((input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse) goto fail;
+  if (input_data == Qfalse && (input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse) goto fail;
 
   /* Try to compile the input_data using input_to_storage(input_data) */
   exception_tag = bs_input_to_storage(handler, Qnil, input_data, path_v, &storage_data);

data/lib/bootsnap/compile_cache/iseq.rb

@@ -172,11 +172,11 @@ module Bootsnap
 
         if RUBY_VERSION < "3.1."
           def self.coverage_on?
-            defined?(Coverage) && Coverage.running?
+            defined?(Coverage.running?) && Coverage.running?
           end
         else
           def self.coverage_on?
-            defined?(Coverage) && Coverage.state != :idle
+            defined?(Coverage.state) && Coverage.state != :idle
           end
         end
 

data/lib/bootsnap/compile_cache/yaml.rb

@@ -47,14 +47,6 @@ module Bootsnap
           SUPPORTED_INTERNAL_ENCODINGS.include?(Encoding.default_internal)
         end
 
-        module EncodingAwareSymbols
-          extend self
-
-          def unpack(payload)
-            (+payload).force_encoding(Encoding::UTF_8).to_sym
-          end
-        end
-
         def init!
           require "yaml"
           require "msgpack"
@@ -86,28 +78,78 @@ module Bootsnap
             0x00,
             Symbol,
             packer: :to_msgpack_ext,
-            unpacker: EncodingAwareSymbols.method(:unpack).to_proc,
+            unpacker: :from_msgpack_ext,
+            optimized_symbol_parsing: true,
           )
 
-          if defined? MessagePack::Timestamp
-            factory.register_type(
-              MessagePack::Timestamp::TYPE, # or just -1
-              Time,
-              packer: MessagePack::Time::Packer,
-              unpacker: MessagePack::Time::Unpacker,
-            )
+          factory.register_type(
+            MessagePack::Timestamp::TYPE, # or just -1
+            Time,
+            packer: MessagePack::Time::Packer,
+            unpacker: MessagePack::Time::Unpacker,
+          )
 
-            marshal_fallback = {
-              packer: ->(value) { Marshal.dump(value) },
-              unpacker: ->(payload) { Marshal.load(payload) },
-            }
-            {
-              Date => 0x01,
-              Regexp => 0x02,
-            }.each do |type, code|
-              factory.register_type(code, type, marshal_fallback)
-            end
-          end
+          factory.register_type(
+            0x01,
+            Date,
+            packer: lambda { |date, packer|
+              packer.write(date.year)
+              packer.write(date.month)
+              packer.write(date.day)
+            },
+            unpacker: lambda { |unpacker|
+              ::Date.new(unpacker.read, unpacker.read, unpacker.read)
+            },
+            recursive: true,
+          )
+
+          factory.register_type(
+            0x02,
+            Regexp,
+            packer: ->(value) { Marshal.dump(value) },
+            unpacker: ->(payload) { Marshal.load(payload) },
+          )
+
+          factory.register_type(
+            0x03,
+            DateTime,
+            packer: lambda { |dt, packer|
+              packer.write(dt.year)
+              packer.write(dt.month)
+              packer.write(dt.day)
+              packer.write(dt.hour)
+              packer.write(dt.minute)
+
+              sec = dt.sec + dt.sec_fraction
+              packer.write(sec.numerator)
+              packer.write(sec.denominator)
+
+              offset = dt.offset
+              packer.write(offset.numerator)
+              packer.write(offset.denominator)
+            },
+            unpacker: lambda { |unpacker|
+              ::DateTime.new(
+                unpacker.read, # year
+                unpacker.read, # month
+                unpacker.read, # day
+                unpacker.read, # hour
+                unpacker.read, # minute
+                Rational(unpacker.read, unpacker.read), # sec fraction
+                Rational(unpacker.read, unpacker.read), # offset fraction
+              )
+            },
+            recursive: true,
+          )
+
+          require "msgpack/bigint"
+          factory.register_type(
+            0x04,
+            Integer,
+            packer: MessagePack::Bigint.method(:to_msgpack_ext),
+            unpacker: MessagePack::Bigint.method(:from_msgpack_ext),
+            oversized_integer_extension: true,
+          )
 
           self.msgpack_factory = factory
 
@@ -116,7 +158,7 @@ module Bootsnap
           if params.include?([:key, :symbolize_names])
             supported_options << :symbolize_names
           end
-          if params.include?([:key, :freeze]) && factory.load(factory.dump("yaml"), freeze: true).frozen?
+          if params.include?([:key, :freeze])
             supported_options << :freeze
           end
           supported_options.freeze
@@ -135,6 +177,14 @@ module Bootsnap
 
           NoTagsVisitor.new(scanner, loader).visit(ast)
         end
+
+        def msgpack_unpacker_options(kwargs)
+          return kwargs unless kwargs&.key?(:symbolize_names)
+
+          kwargs = kwargs.dup
+          kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+          kwargs
+        end
       end
 
       module Psych4
@@ -164,11 +214,9 @@ module Bootsnap
           end
 
           def storage_to_output(data, kwargs)
-            if kwargs&.key?(:symbolize_names)
-              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
-            end
-
-            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(
+              CompileCache::YAML.msgpack_unpacker_options(kwargs),
+            )
             unpacker.feed(data)
             _safe_loaded = unpacker.unpack
             result = unpacker.unpack
@@ -202,11 +250,9 @@ module Bootsnap
           end
 
           def storage_to_output(data, kwargs)
-            if kwargs&.key?(:symbolize_names)
-              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
-            end
-
-            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(
+              CompileCache::YAML.msgpack_unpacker_options(kwargs),
+            )
             unpacker.feed(data)
             safe_loaded = unpacker.unpack
             if safe_loaded
@@ -282,10 +328,9 @@ module Bootsnap
         end
 
         def storage_to_output(data, kwargs)
-          if kwargs&.key?(:symbolize_names)
-            kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
-          end
-          unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+          unpacker = CompileCache::YAML.msgpack_factory.unpacker(
+            CompileCache::YAML.msgpack_unpacker_options(kwargs),
+          )
           unpacker.feed(data)
           _safe_loaded = unpacker.unpack
           unpacker.unpack

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.24.6"
+  VERSION = "1.26.0"
 end

data/lib/bootsnap.rb

@@ -6,6 +6,9 @@ require_relative "bootsnap/bundler"
 module Bootsnap
   InvalidConfiguration = Class.new(StandardError)
 
+  # JITs shouldn't change the cache key as they have no impact on iseq generation
+  RUBY_CACHE_KEY = RUBY_DESCRIPTION.gsub(/\s\+\wJIT/, "").freeze
+
   class << self
     attr_reader :cache_dir, :logger
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.24.6
+  version: 1.26.0
 platform: ruby
 authors:
 - Burke Libbey
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
 description: Boot large ruby/rails apps faster
 email:
 - burke.libbey@shopify.com
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []