Support Linuxulator on FreeBSD

Author: ntkme

.github/workflows/build.yml

@@ -80,7 +80,26 @@ jobs:
           - os: ubuntu-latest
             vm:
               os: freebsd
-              run: pkg install -y node npm protobuf ruby rubygem-bundler rubygem-rake
+              run: |
+                pkg install -y node npm protobuf ruby rubygem-bundler rubygem-rake
+          - os: ubuntu-latest
+            vm:
+              os: freebsd
+              run: |
+                pkg install -y node npm ruby rubygem-bundler rubygem-rake
+                sysrc linux_enable="YES"
+                service linux start
+          - os: ubuntu-latest
+            vm:
+              os: freebsd
+              run: |
+                pkg install -y debootstrap ruby rubygem-bundler rubygem-rake
+                sysrc linux_enable="YES"
+                service linux start
+                debootstrap jammy /compat/ubuntu
+                ln -sf ../lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /compat/ubuntu/lib64/ld-linux-x86-64.so.2
+                mount -t linprocfs linproc /compat/ubuntu/proc
+                sysctl compat.linux.emul_path=/compat/ubuntu
           - os: ubuntu-latest
             vm:
               os: openbsd
@@ -90,11 +109,13 @@ jobs:
           - os: ubuntu-latest
             vm:
               os: netbsd
-              run: /usr/sbin/pkg_add nodejs protobuf ruby
+              run: |
+                /usr/sbin/pkg_add nodejs protobuf ruby
           - os: ubuntu-latest
             vm:
               os: dragonflybsd
-              run: pkg install -y libnghttp2 libuv node npm protobuf ruby rubygem-bundler rubygem-rake
+              run: |
+                pkg install -y libnghttp2 libuv node npm protobuf ruby rubygem-bundler rubygem-rake
           - os: ubuntu-latest
             vm:
               os: omnios
@@ -139,7 +160,7 @@ jobs:
         run: bundle exec rake compile
 
       - name: Spec
-        if: "!matrix.vm" # TODO: remove after https://github.com/sass/dart-sass/pull/2413
+        if: "!matrix.vm || contains(matrix.vm.run, 'sysctl compat.linux.emul_path')" # TODO: remove after https://github.com/sass/dart-sass/pull/2413
         run: bundle exec rake spec
 
       - name: Install

ext/sass/.gitignore

@@ -10,4 +10,5 @@
 /pnpm-lock.yaml
 /protoc.exe
 /ruby/
+/true-*
 /yarn.lock

ext/sass/Rakefile

@@ -2,6 +2,10 @@
 
 require 'rake/clean'
 
+require_relative '../../lib/sass/elf'
+
+ELF = Sass.const_get(:ELF)
+
 task default: %i[install clean]
 
 task install: %w[cli.rb] do
@@ -11,6 +15,7 @@ end
 CLEAN.include %w[
   protoc.exe
   ruby
+  true-*
   *.proto
   *.tar.gz
   *.zip
@@ -65,13 +70,20 @@ end
 
 task 'dart-sass' do
   Rake::Task['dart-sass/sass'].invoke
+
+  if SassConfig.linuxulator?
+    begin
+      sh 'dart-sass/sass', File::NULL
+    rescue StandardError
+      rm_rf 'dart-sass'
+      raise NotImplementedError
+    end
+  end
 rescue NotImplementedError
   Rake::Task['node_modules/sass'].invoke
 end
 
 file 'cli.rb' => %w[dart-sass] do |t|
-  require_relative '../../lib/sass/elf'
-
   begin
     exe = 'dart-sass/sass'
     exe = "#{exe}#{['', '.bat', '.exe'].find { |ext| File.exist?("#{exe}#{ext}") }}"
@@ -89,7 +101,7 @@ file 'cli.rb' => %w[dart-sass] do |t|
               end
 
     interpreter = File.open(command[0], 'rb') do |file|
-      Sass.const_get(:ELF).new(file).interpreter
+      ELF.new(file).interpreter
     rescue ArgumentError
       nil
     end
@@ -158,6 +170,119 @@ rule '_pb.rb' => %w[.proto protoc.exe] do |t|
   sh './protoc.exe', '--proto_path=.', '--ruby_out=.', t.source
 end
 
+rule(/^true-\w+$/) do |t|
+  case t.name.delete_prefix('true-')
+  when 'aarch64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0xb7
+    e_flags   = 0
+
+    # 0x0000000000000078:  A8 0B 80 D2    mov x8, #0x5d
+    # 0x000000000000007c:  00 00 80 D2    mov x0, #0
+    # 0x0000000000000080:  01 00 00 D4    svc #0
+    entry_point = ['a80b80d2000080d2010000d4'].pack('H*')
+  when 'arm'
+    ei_class  = ELF::ELFCLASS32
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x28
+    e_flags   = 0x5000400
+
+    # 0x0000000000000054:  00 00 A0 E3    mov r0, #0
+    # 0x0000000000000058:  01 70 A0 E3    mov r7, #1
+    # 0x000000000000005c:  00 00 00 EF    svc #0
+    entry_point = ['0000a0e30170a0e3000000ef'].pack('H*')
+  when 'riscv64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0xf3
+    e_flags   = 0x5
+
+    # 0x0000000000000078:  93 08 D0 05    addi  a7, x0, 93
+    # 0x000000000000007c:  01 45          c.li  a0, 0
+    # 0x000000000000007e:  73 00 00 00    ecall
+    entry_point = ['9308d005014573000000'].pack('H*')
+  when 'x86_64'
+    ei_class  = ELF::ELFCLASS64
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x3e
+    e_flags   = 0
+
+    # 0x0000000000000078:  31 FF             xor     edi, edi
+    # 0x000000000000007a:  B8 3C 00 00 00    mov     eax, 0x3c
+    # 0x000000000000007f:  0F 05             syscall
+    entry_point = ['31ffb83c0000000f05'].pack('H*')
+  when 'i386'
+    ei_class  = ELF::ELFCLASS32
+    ei_data   = ELF::ELFDATA2LSB
+    e_machine = 0x03
+    e_flags   = 0
+
+    # 0x0000000000000054:  31 DB             xor ebx, ebx
+    # 0x0000000000000056:  B8 01 00 00 00    mov eax, 1
+    # 0x000000000000005b:  CD 80             int 0x80
+    entry_point = ['31dbb801000000cd80'].pack('H*')
+  else
+    raise NotImplementedError
+  end
+
+  File.open(t.name, 'wb', 0o755) do |file|
+    ELF.allocate.instance_eval do
+      case ei_class
+      when ELF::ELFCLASS32
+        e_ehsize    = ELF::Elf32_Ehdr.sizeof
+        e_phentsize = ELF::Elf32_Phdr.sizeof
+        e_shentsize = ELF::Elf32_Shdr.sizeof
+      when ELF::ELFCLASS64
+        e_ehsize    = ELF::Elf64_Ehdr.sizeof
+        e_phentsize = ELF::Elf64_Phdr.sizeof
+        e_shentsize = ELF::Elf64_Shdr.sizeof
+      else
+        raise EncodingError
+      end
+      e_phoff  = e_ehsize
+      p_offset = e_phoff + e_phentsize
+      e_entry  = (2**22) + p_offset
+      p_vaddr  = e_entry
+      p_filesz = entry_point.length
+      p_memsz  = p_filesz
+
+      @ehdr = {
+        e_ident: [127, 69, 76, 70, ei_class, ei_data, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        e_type: ELF::ET_EXEC,
+        e_machine:,
+        e_version: 1,
+        e_entry:,
+        e_phoff:,
+        e_shoff: 0,
+        e_flags:,
+        e_ehsize:,
+        e_phentsize:,
+        e_phnum: 1,
+        e_shentsize:,
+        e_shnum: 0,
+        e_shstrndx: 0
+      }
+      @phdrs = [
+        {
+          p_type: ELF::PT_LOAD,
+          p_flags: ELF::PF_R | ELF::PF_X,
+          p_offset:,
+          p_vaddr:,
+          p_paddr: 0,
+          p_filesz:,
+          p_memsz:,
+          p_align: 4096
+        }
+      ]
+      @shdrs = []
+
+      dump(file)
+    end
+    file.write(entry_point)
+  end
+end
+
 # This is a FileUtils extension that defines several additional commands to be
 # added to the FileUtils utility functions.
 module FileUtils
@@ -305,23 +430,6 @@ end
 # The {SassConfig} module.
 module SassConfig
   module Platform
-    OS = case RbConfig::CONFIG['host_os'].downcase
-         when /darwin/
-           'darwin'
-         when /linux-android/
-           'linux-android'
-         when /linux-musl/
-           'linux-musl'
-         when /linux-uclibc/
-           'linux-uclibc'
-         when /linux/
-           'linux'
-         when *Gem::WIN_PATTERNS
-           'windows'
-         else
-           RbConfig::CONFIG['host_os'].downcase
-         end
-
     CPU = case RbConfig::CONFIG['host_cpu'].downcase
           when /amd64|x86_64|x64/
             'x86_64'
@@ -337,13 +445,97 @@ module SassConfig
             RbConfig::CONFIG['host_cpu']
           end
 
+    LINUXULATOR = begin
+      raise NotImplementedError unless RbConfig::CONFIG['host_os'].include?('freebsd')
+
+      Rake::Task["true-#{CPU}"].invoke
+
+      raise NotImplementedError unless system("./true-#{CPU}")
+
+      begin
+        require 'fiddle'
+
+        lib = Fiddle.dlopen(nil)
+        sysctlbyname = Fiddle::Function.new(
+          lib['sysctlbyname'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T],
+          Fiddle::TYPE_INT
+        )
+
+        name = Fiddle::Pointer.to_ptr('compat.linux.emul_path')
+        oldp = Fiddle::NULL
+        oldlenp = Fiddle::Pointer.malloc(Fiddle::SIZEOF_SIZE_T, Fiddle::RUBY_FREE)
+        newp = Fiddle::NULL
+        newlen = 0
+        raise SystemCallError.new(nil, Fiddle.last_error) if sysctlbyname.call(name, oldp, oldlenp, newp, newlen) == -1
+
+        oldp = Fiddle::Pointer.malloc(oldlenp.ptr.to_i, Fiddle::RUBY_FREE)
+        raise SystemCallError.new(nil, Fiddle.last_error) if sysctlbyname.call(name, oldp, oldlenp, newp, newlen) == -1
+
+        path = oldp.to_s
+      rescue SystemCallError
+        raise NotImplementedError
+      end
+
+      RbConfig::CONFIG['host_os'] = case
+                                    when (CPU == 'aarch64' &&
+                                          File.exist?(File.absolute_path('lib/ld-linux-aarch64.so.1', path))) ||
+                                         (CPU == 'arm' &&
+                                          File.exist?(File.absolute_path('lib/ld-linux-armhf.so.3', path))) ||
+                                         (CPU == 'riscv64' &&
+                                          File.exist?(File.absolute_path('lib/ld-linux-riscv64-lp64d.so.1', path))) ||
+                                         (CPU == 'x86_64' &&
+                                          File.exist?(File.absolute_path('lib64/ld-linux-x86-64.so.2', path))) ||
+                                         (CPU == 'i386' &&
+                                          File.exist?(File.absolute_path('lib/ld-linux.so.2', path)))
+                                      'linux-gnu'
+                                    when ((CPU == 'aarch64' || CPU == 'riscv64' || CPU == 'x86_64' || CPU == 'i386') &&
+                                          File.exist?(File.absolute_path("lib/ld-musl-#{CPU}.so.1", path))) ||
+                                         (CPU == 'arm' &&
+                                          File.exist?(File.absolute_path('lib/ld-musl-armhf.so.1', path)))
+                                      'linux-musl'
+                                    when ((CPU == 'aarch64' || CPU == 'riscv64' || CPU == 'x86_64') &&
+                                          File.exist?(File.absolute_path('system/bin/linker64', path))) ||
+                                         ((CPU == 'arm' || CPU == 'i386') &&
+                                          File.exist?(File.absolute_path('system/bin/linker', path)))
+                                      'linux-android'
+                                    else
+                                      'linux-none'
+                                    end
+
+      true
+    rescue NotImplementedError
+      false
+    end
+
+    OS = case RbConfig::CONFIG['host_os'].downcase
+         when /darwin/
+           'darwin'
+         when /linux-android/
+           'linux-android'
+         when /linux-musl/
+           'linux-musl'
+         when /linux-none/
+           'linux-none'
+         when /linux/
+           'linux'
+         when *Gem::WIN_PATTERNS
+           'windows'
+         else
+           RbConfig::CONFIG['host_os'].downcase
+         end
+
     ARCH = "#{CPU}-#{OS}".freeze
   end
 
   private_constant :Platform
 
   module_function
 
+  def linuxulator?
+    Platform::LINUXULATOR
+  end
+
   def package_json(path = '.')
     require 'json'
 
@@ -415,7 +607,7 @@ module SassConfig
     os = case Platform::OS
          when 'darwin'
            'osx'
-         when 'linux', 'linux-android', 'linux-musl', 'linux-uclibc'
+         when 'linux', 'linux-android', 'linux-musl', 'linux-none'
            'linux'
          when 'windows'
            'windows'