Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 34 additions & 0 deletions internal/vm/dir.go
Original file line number Diff line number Diff line change
Expand Up @@ -151,6 +151,22 @@ func (vm *VM) registerDir() {
}
return object.IntValue(0)
})
// Dir.chroot(path) changes the process root to path and returns 0 (dir.c
// dir_s_chroot: check_dirname then chroot(2), rb_sys_fail_path on -1). A
// non-privileged process cannot chroot, so the real call fails with
// Errno::EPERM — the behaviour the spec exercises as a regular user. The path
// is a rb_get_path argument (#to_path). chrootFn is a platform seam so the
// error mapping is testable without re-rooting the test process.
def("chroot", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value {
if len(args) != 1 {
raise("ArgumentError", "wrong number of arguments (given %d, expected 1)", len(args))
}
p := pathArg(vm, args[0])
if err := chrootFn(p); err != nil {
raiseChrootErr(err, p)
}
return object.IntValue(0)
})
// Dir.each_child(path) yields each child name (no "." / ".."); Dir.foreach(path)
// yields every entry including "." and "..". Both return nil after a block and,
// with no block, an Enumerator over the snapshot names (MRI dir.c) — whose #size
Expand Down Expand Up @@ -390,6 +406,24 @@ func dirPwd(_ *VM, _ object.Value, _ []object.Value, _ *Proc) object.Value {
return object.NewString(toSlash(wd))
}

// raiseChrootErr maps a chroot(2) failure to the MRI errno Dir.chroot raises via
// rb_sys_fail_path: a permission failure (the ordinary case for a non-root
// process, and what macOS returns even for a missing path) is Errno::EPERM, a
// missing directory Errno::ENOENT, a non-directory Errno::ENOTDIR, and anything
// else falls back to Errno::EPERM. Each is a SystemCallError, as the spec checks.
func raiseChrootErr(err error, path string) {
switch {
case os.IsPermission(err):
raise("Errno::EPERM", "Operation not permitted @ dir_s_chroot - %s", path)
case os.IsNotExist(err):
raise("Errno::ENOENT", "No such file or directory @ dir_s_chroot - %s", path)
case errors.Is(err, syscall.ENOTDIR):
raise("Errno::ENOTDIR", "Not a directory @ dir_s_chroot - %s", path)
default:
raise("Errno::EPERM", "Operation not permitted @ dir_s_chroot - %s", path)
}
}

// includeDirEnumerable mixes the prelude-defined Enumerable module into Dir. It
// runs post-prelude (registerDir itself runs before the prelude, so the module
// does not exist yet there), driven from registerFileStat which also runs after
Expand Down
37 changes: 36 additions & 1 deletion internal/vm/file.go
Original file line number Diff line number Diff line change
Expand Up @@ -344,7 +344,7 @@ func (vm *VM) registerFile() {
return object.IntValue(int64(len(paths)))
})
def("utime", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value {
at, mt := timeArgUnix(args[0]), timeArgUnix(args[1])
at, mt := timeArgUnixOrNow(args[0]), timeArgUnixOrNow(args[1])
paths := args[2:]
for _, a := range paths {
p := pathArg(vm, a)
Expand All @@ -354,6 +354,31 @@ func (vm *VM) registerFile() {
}
return object.IntValue(int64(len(paths)))
})
// File.lutime(atime, mtime, *paths) sets each path's access/modification time
// like File.utime but WITHOUT following a final symbolic link, returning the
// number of paths (file.c utime_internal with follow=TRUE -> AT_SYMLINK_NOFOLLOW).
// A nil atime/mtime means the current time; lutimesFn is the POSIX seam.
def("lutime", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value {
if len(args) < 2 {
raise("ArgumentError", "wrong number of arguments (given %d, expected 2+)", len(args))
}
at, mt := timeArgUnixOrNow(args[0]), timeArgUnixOrNow(args[1])
paths := args[2:]
for _, a := range paths {
p := pathArg(vm, a)
if err := lutimesFn(p, at, mt); err != nil {
raise("Errno::ENOENT", "No such file or directory @ utime_failed - %s", p)
}
}
return object.IntValue(int64(len(paths)))
})
// NOTE: File.mkfifo (syscall.Mkfifo) is deliberately left unregistered. It is
// straightforward and MRI-verified, but wiring it up REGRESSES core/file:
// open_spec's "on a FIFO" example opens both ends of the FIFO from two Ruby
// threads, and rbgo's blocking File.open (io.go) deadlocks the interpreter on
// the FIFO open(2) handshake — hanging the whole spec file and losing its ~55
// passing examples. Add File.mkfifo only once File.open on a FIFO no longer
// blocks the scheduler (an io.go / thread-concurrency fix the io agent owns).
// File.umask([mask]) reads (and optionally sets) the process umask, returning
// the previous value — the bracket Puppet::Util.withumask uses. With no
// argument it reports the current umask without changing it.
Expand Down Expand Up @@ -959,3 +984,13 @@ func timeArgUnix(v object.Value) int64 {
}
return int64(numFloat(v))
}

// timeArgUnixOrNow is timeArgUnix with MRI's nil handling for File.utime /
// File.lutime: a nil atime/mtime means "use the current time" (file.c
// utime_internal leaves the timespec NULL, which utimensat reads as UTIME_NOW).
func timeArgUnixOrNow(v object.Value) int64 {
if v == object.NilV {
return stdtime.Now().Unix()
}
return timeArgUnix(v)
}
114 changes: 114 additions & 0 deletions internal/vm/file_lutime_chroot_internal_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,114 @@
// Copyright (c) the go-embedded-ruby/ruby authors
//
// SPDX-License-Identifier: BSD-3-Clause

package vm

import (
"errors"
"os"
"runtime"
"syscall"
"testing"
)

// origChrootFn / origLutimesFn capture the platform seams so each test can
// restore them after swapping in a deterministic stub (the real chroot seam must
// never actually run in a test — it would re-root the test process).
var (
origChrootFn = chrootFn
origLutimesFn = lutimesFn
)

func restoreFDSeams() {
chrootFn = origChrootFn
lutimesFn = origLutimesFn
}

// TestFileLutime covers File.lutime: the real utimensat(AT_SYMLINK_NOFOLLOW)
// seam on POSIX (setting a regular file's time and returning the path count),
// the nil-means-now branch, the arity guard, and the ENOENT error branch via a
// failing seam. Verified against MRI Ruby 4.0.5 (File.lutime returns the number
// of file names; file.c utime_internal with follow=TRUE -> AT_SYMLINK_NOFOLLOW).
func TestFileLutime(t *testing.T) {
defer restoreFDSeams()

// File.lutime is registered only under the unix build tag; on Windows the
// method is absent (NoMethodError), so its POSIX assertions don't apply. The
// 100% coverage gate runs on the POSIX lanes, so coverage is unaffected.
if runtime.GOOS == "windows" {
t.Skip("File.lutime is POSIX-only")
}
if runtime.GOOS != "windows" {
dir := slash(t.TempDir())
f := dir + "/f"
if err := os.WriteFile(dir+"/f", []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
// Real call exercises the lutimesFn body: returns the path count.
if got := runFS(t, `p File.lutime(Time.at(1000000000), Time.at(1000000001), "`+f+`")`); got != "1\n" {
t.Errorf("lutime real: got %q want 1", got)
}
// mtime was set to the second argument.
if got := runFS(t, `p (File.mtime("`+f+`").to_i == 1000000001)`); got != "true\n" {
t.Errorf("lutime mtime: got %q want true", got)
}
// nil atime/mtime means the current time (timeArgUnixOrNow nil branch).
if got := runFS(t, `File.lutime(nil, nil, "`+f+`"); p ((Time.now.to_i - File.mtime("`+f+`").to_i).abs < 5)`); got != "true\n" {
t.Errorf("lutime nil: got %q want true", got)
}
}

// Arity guard: fewer than two arguments is an ArgumentError.
if got := runFSErr(t, `File.lutime(0)`); got != "ArgumentError" {
t.Errorf("lutime arity: got %q want ArgumentError", got)
}

// Error branch: a failing seam maps to Errno::ENOENT.
lutimesFn = func(string, int64, int64) error { return os.ErrNotExist }
if got := runFSErr(t, `File.lutime(0, 0, "x")`); got != "Errno::ENOENT" {
t.Errorf("lutime err: got %q want Errno::ENOENT", got)
}
}

// TestDirChroot covers Dir.chroot: the success return (0) and each
// raiseChrootErr errno branch, all through the chrootFn seam so the real chroot
// (which would re-root the test process) never runs. Verified against MRI Ruby
// 4.0.5 (Dir.chroot returns 0; a regular user gets Errno::EPERM; dir.c
// dir_s_chroot, rb_sys_fail_path).
func TestDirChroot(t *testing.T) {
defer restoreFDSeams()

// Dir.chroot is registered only under the unix build tag; absent on Windows
// (NoMethodError). The 100% coverage gate runs on the POSIX lanes.
if runtime.GOOS == "windows" {
t.Skip("Dir.chroot is POSIX-only")
}

// Success: seam returns nil, Dir.chroot returns 0.
chrootFn = func(string) error { return nil }
if got := runFS(t, `p Dir.chroot(".")`); got != "0\n" {
t.Errorf("chroot success: got %q want 0", got)
}

// Arity guard.
if got := runFSErr(t, `Dir.chroot(".", ".")`); got != "ArgumentError" {
t.Errorf("chroot arity: got %q want ArgumentError", got)
}

// raiseChrootErr branches.
for _, c := range []struct {
err error
want string
}{
{syscall.EPERM, "Errno::EPERM"},
{syscall.ENOENT, "Errno::ENOENT"},
{syscall.ENOTDIR, "Errno::ENOTDIR"},
{errors.New("other"), "Errno::EPERM"},
} {
chrootFn = func(string) error { return c.err }
if got := runFSErr(t, `Dir.chroot("x")`); got != c.want {
t.Errorf("chroot err %v: got %q want %q", c.err, got, c.want)
}
}
}
26 changes: 26 additions & 0 deletions internal/vm/filestat_unix.go
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,32 @@ package vm
import (
"io/fs"
"syscall"

"golang.org/x/sys/unix"
)

// chrootFn and lutimesFn are the POSIX seams behind Dir.chroot and File.lutime.
// On Unix they map onto the real system calls; the windows/wasm builds supply
// unsupported stubs (both methods are guarded `platform_is_not :windows` in the
// specs). Each is a function variable so a whitebox test can substitute a stub
// and drive the Errno mapping without the real syscall — chroot in particular
// must never be allowed to re-root the test process, so its error branches are
// exercised only through a swapped seam.
var (
// Dir.chroot(path) -> 0 (dir.c dir_s_chroot, rb_sys_fail_path on -1); a
// non-root process fails with EPERM.
chrootFn = syscall.Chroot
// lutimesFn sets a path's access/modification time WITHOUT following a final
// symbolic link — utimensat(AT_FDCWD, path, ts, AT_SYMLINK_NOFOLLOW), the
// no-follow that distinguishes File.lutime from File.utime (file.c
// utime_internal passes follow=TRUE, which maps to AT_SYMLINK_NOFOLLOW).
lutimesFn = func(path string, atime, mtime int64) error {
ts := []unix.Timespec{
unix.NsecToTimespec(atime * int64(1e9)),
unix.NsecToTimespec(mtime * int64(1e9)),
}
return unix.UtimesNanoAt(unix.AT_FDCWD, path, ts, unix.AT_SYMLINK_NOFOLLOW)
}
)

// statSys extracts the POSIX stat fields (uid/gid/ino/dev/nlink/blksize) from an
Expand Down
10 changes: 10 additions & 0 deletions internal/vm/filestat_wasm.go
Original file line number Diff line number Diff line change
Expand Up @@ -7,10 +7,20 @@
package vm

import (
"errors"
"io/fs"
"syscall"
)

// chrootFn / lutimesFn are unsupported under GOARCH=wasm: Dir.chroot and
// File.lutime are both guarded `platform_is_not :windows` in the specs and have
// no wasip1/js system call, so these stubs exist only to satisfy the seam the
// shared dir.go / file.go code references.
var (
chrootFn = func(string) error { return errors.ErrUnsupported }
lutimesFn = func(string, int64, int64) error { return errors.ErrUnsupported }
)

// statSys is the GOARCH=wasm counterpart of the Unix syscall.Stat_t extraction.
// Under wasip1 the os package still populates FileInfo.Sys() with a
// *syscall.Stat_t, but that struct is a WASI-preview1 subset: it carries
Expand Down
14 changes: 13 additions & 1 deletion internal/vm/filestat_windows.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,19 @@

package vm

import "io/fs"
import (
"errors"
"io/fs"
)

// chrootFn / lutimesFn are unsupported on Windows: Dir.chroot and File.lutime are
// both guarded `platform_is_not :windows` in the specs, so these stubs exist only
// to satisfy the seam the shared dir.go / file.go code references, reporting the
// operation as unsupported.
var (
chrootFn = func(string) error { return errors.ErrUnsupported }
lutimesFn = func(string, int64, int64) error { return errors.ErrUnsupported }
)

// statSys is the Windows counterpart of the Unix syscall.Stat_t extraction.
// Windows has no Stat_t (no uid/gid/inode model), so the POSIX-only fields take
Expand Down