pkg os, method (*Root) Chtimes(string, time.Time, time.Time) error #67002
pkg os, method (*Root) Lchown(string, int, int) error #67002
pkg os, method (*Root) Readlink(string) (string, error) #67002
+pkg os, method (*Root) Rename(string, string) error #67002
* [os.Root.Chtimes]
* [os.Root.Lchown]
* [os.Root.Readlink]
+ * [os.Root.Rename]
TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0; JMP libc_mkdirat(SB)
TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0; JMP libc_fchmodat(SB)
TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0; JMP libc_fchownat(SB)
+TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0; JMP libc_renameat(SB)
JMP libc_fchmodat(SB)
TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
JMP libc_fchownat(SB)
+TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
+ JMP libc_renameat(SB)
}
return nil
}
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
+ oldp, err := syscall.BytePtrFromString(oldpath)
+ if err != nil {
+ return err
+ }
+ newp, err := syscall.BytePtrFromString(newpath)
+ if err != nil {
+ return err
+ }
+ _, _, errno := syscall.Syscall6(renameatTrap,
+ uintptr(olddirfd),
+ uintptr(unsafe.Pointer(oldp)),
+ uintptr(newdirfd),
+ uintptr(unsafe.Pointer(newp)),
+ 0,
+ 0)
+ if errno != 0 {
+ return errno
+ }
+ return nil
+}
}
return nil
}
+
+func libc_renameat_trampoline()
+
+//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
+ oldp, err := syscall.BytePtrFromString(oldpath)
+ if err != nil {
+ return err
+ }
+ newp, err := syscall.BytePtrFromString(newpath)
+ if err != nil {
+ return err
+ }
+ _, _, errno := syscall_syscall6(abi.FuncPCABI0(libc_renameat_trampoline),
+ uintptr(olddirfd),
+ uintptr(unsafe.Pointer(oldp)),
+ uintptr(newdirfd),
+ uintptr(unsafe.Pointer(newp)),
+ 0,
+ 0)
+ if errno != 0 {
+ return errno
+ }
+ return nil
+}
//go:linkname procMkdirat libc_mkdirat
//go:linkname procFchmodat libc_fchmodat
//go:linkname procFchownat libc_fchownat
+//go:linkname procRenameat libc_renameat
var (
procFstatat,
procReadlinkat,
procMkdirat,
procFchmodat,
- procFchownat uintptr
+ procFchownat,
+ procRenameat uintptr
)
func Unlinkat(dirfd int, path string, flags int) error {
}
return nil
}
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
+ oldp, err := syscall.BytePtrFromString(oldpath)
+ if err != nil {
+ return err
+ }
+ newp, err := syscall.BytePtrFromString(newpath)
+ if err != nil {
+ return err
+ }
+ _, _, errno := syscall6(uintptr(unsafe.Pointer(&procRenameat)), 4,
+ uintptr(olddirfd),
+ uintptr(unsafe.Pointer(oldp)),
+ uintptr(newdirfd),
+ uintptr(unsafe.Pointer(newp)),
+ 0,
+ 0)
+ if errno != 0 {
+ return errno
+ }
+ return nil
+}
}
return nil
}
+
+//go:cgo_import_dynamic libc_renameat renameat "libc.so"
+
+func libc_renameat_trampoline()
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
+ oldp, err := syscall.BytePtrFromString(oldpath)
+ if err != nil {
+ return err
+ }
+ newp, err := syscall.BytePtrFromString(newpath)
+ if err != nil {
+ return err
+ }
+ _, _, errno := syscall_syscall6(abi.FuncPCABI0(libc_renameat_trampoline),
+ uintptr(olddirfd),
+ uintptr(unsafe.Pointer(oldp)),
+ uintptr(newdirfd),
+ uintptr(unsafe.Pointer(newp)),
+ 0,
+ 0)
+ if errno != 0 {
+ return errno
+ }
+ return nil
+}
//go:cgo_import_dynamic libc_fchownat fchownat "libc.so"
//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"
//go:cgo_import_dynamic libc_openat openat "libc.so"
+//go:cgo_import_dynamic libc_renameat renameat "libc.so"
//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so"
//go:cgo_import_dynamic libc_readlinkat readlinkat "libc.so"
//go:cgo_import_dynamic libc_mkdirat mkdirat "libc.so"
mkdiratTrap uintptr = syscall.SYS_MKDIRAT
fchmodatTrap uintptr = syscall.SYS_FCHMODAT
fchownatTrap uintptr = syscall.SYS_FCHOWNAT
+ renameatTrap uintptr = syscall.SYS_RENAMEAT
AT_EACCESS = 0x4
AT_FDCWD = 0xfffafdcd
mkdiratTrap uintptr = syscall.SYS_MKDIRAT
fchmodatTrap uintptr = syscall.SYS_FCHMODAT
fchownatTrap uintptr = syscall.SYS_FCHOWNAT
+ renameatTrap uintptr = syscall.SYS_RENAMEAT
)
mkdiratTrap uintptr = syscall.SYS_MKDIRAT
fchmodatTrap uintptr = syscall.SYS_FCHMODAT
fchownatTrap uintptr = syscall.SYS_FCHOWNAT
+ renameatTrap uintptr = syscall.SYS_RENAMEAT
)
const (
return syscall.ENOSYS
}
+//go:wasmimport wasi_snapshot_preview1 path_rename
+//go:noescape
+func path_rename(oldFd int32, oldPath *byte, oldPathLen size, newFd int32, newPath *byte, newPathLen size) syscall.Errno
+
+func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
+ if oldpath == "" || newpath == "" {
+ return syscall.EINVAL
+ }
+ return errnoErr(path_rename(
+ int32(olddirfd),
+ unsafe.StringData(oldpath),
+ size(len(oldpath)),
+ int32(newdirfd),
+ unsafe.StringData(newpath),
+ size(len(newpath)),
+ ))
+}
+
//go:wasmimport wasi_snapshot_preview1 path_create_directory
//go:noescape
func path_create_directory(fd int32, path *byte, pathLen size) syscall.Errno
--- /dev/null
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux && (loong64 || riscv64)
+
+package unix
+
+import "syscall"
+
+const (
+ // loong64 and riscv64 only have renameat2.
+ // renameat2 has an extra flags parameter.
+ // When called with a 0 flags it is identical to renameat.
+ renameatTrap uintptr = syscall.SYS_RENAMEAT2
+)
--- /dev/null
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux && !(loong64 || riscv64)
+
+package unix
+
+import "syscall"
+
+const (
+ renameatTrap uintptr = syscall.SYS_RENAMEAT
+)
}
return err
}
+
+func Renameat(olddirfd syscall.Handle, oldpath string, newdirfd syscall.Handle, newpath string) error {
+ objAttrs := &OBJECT_ATTRIBUTES{}
+ if err := objAttrs.init(olddirfd, oldpath); err != nil {
+ return err
+ }
+ var h syscall.Handle
+ err := NtOpenFile(
+ &h,
+ SYNCHRONIZE|DELETE,
+ objAttrs,
+ &IO_STATUS_BLOCK{},
+ FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE,
+ FILE_OPEN_REPARSE_POINT|FILE_OPEN_FOR_BACKUP_INTENT|FILE_SYNCHRONOUS_IO_NONALERT,
+ )
+ if err != nil {
+ return ntCreateFileError(err, 0)
+ }
+ defer syscall.CloseHandle(h)
+
+ renameInfoEx := FILE_RENAME_INFORMATION_EX{
+ Flags: FILE_RENAME_REPLACE_IF_EXISTS |
+ FILE_RENAME_POSIX_SEMANTICS,
+ RootDirectory: newdirfd,
+ }
+ p16, err := syscall.UTF16FromString(newpath)
+ if err != nil {
+ return err
+ }
+ if len(p16) > len(renameInfoEx.FileName) {
+ return syscall.EINVAL
+ }
+ copy(renameInfoEx.FileName[:], p16)
+ renameInfoEx.FileNameLength = uint32((len(p16) - 1) * 2)
+
+ const (
+ FileRenameInformation = 10
+ FileRenameInformationEx = 65
+ )
+ err = NtSetInformationFile(
+ h,
+ &IO_STATUS_BLOCK{},
+ uintptr(unsafe.Pointer(&renameInfoEx)),
+ uint32(unsafe.Sizeof(FILE_RENAME_INFORMATION_EX{})),
+ FileRenameInformationEx,
+ )
+ if err == nil {
+ return nil
+ }
+
+ // If the prior rename failed, the filesystem might not support
+ // POSIX semantics (for example, FAT), or might not have implemented
+ // FILE_RENAME_INFORMATION_EX.
+ //
+ // Try again.
+ renameInfo := FILE_RENAME_INFORMATION{
+ ReplaceIfExists: true,
+ RootDirectory: newdirfd,
+ }
+ copy(renameInfo.FileName[:], p16)
+ renameInfo.FileNameLength = renameInfoEx.FileNameLength
+
+ err = NtSetInformationFile(
+ h,
+ &IO_STATUS_BLOCK{},
+ uintptr(unsafe.Pointer(&renameInfo)),
+ uint32(unsafe.Sizeof(FILE_RENAME_INFORMATION{})),
+ FileRenameInformation,
+ )
+ if st, ok := err.(NTStatus); ok {
+ return st.Errno()
+ }
+ return err
+}
FILE_DISPOSITION_ON_CLOSE = 0x00000008
FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE = 0x00000010
)
+
+// Flags for FILE_RENAME_INFORMATION_EX.
+const (
+ FILE_RENAME_REPLACE_IF_EXISTS = 0x00000001
+ FILE_RENAME_POSIX_SEMANTICS = 0x00000002
+)
+
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_file_rename_information
+type FILE_RENAME_INFORMATION struct {
+ ReplaceIfExists bool
+ RootDirectory syscall.Handle
+ FileNameLength uint32
+ FileName [syscall.MAX_PATH]uint16
+}
+
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_file_rename_information
+type FILE_RENAME_INFORMATION_EX struct {
+ Flags uint32
+ RootDirectory syscall.Handle
+ FileNameLength uint32
+ FileName [syscall.MAX_PATH]uint16
+}
return rootReadlink(r, name)
}
+// Rename renames (moves) oldname to newname.
+// Both paths are relative to the root.
+// See [Rename] for more details.
+func (r *Root) Rename(oldname, newname string) error {
+ return rootRename(r, oldname, newname)
+}
+
func (r *Root) logOpen(name string) {
if log := testlog.Logger(); log != nil {
// This won't be right if r's name has changed since it was opened,
}
return name, nil
}
+
+func rootRename(r *Root, oldname, newname string) error {
+ if err := checkPathEscapesLstat(r, oldname); err != nil {
+ return &PathError{Op: "renameat", Path: oldname, Err: err}
+ }
+ if err := checkPathEscapesLstat(r, newname); err != nil {
+ return &PathError{Op: "renameat", Path: newname, Err: err}
+ }
+ err := Rename(joinPath(r.root.name, oldname), joinPath(r.root.name, newname))
+ if err != nil {
+ return &LinkError{"renameat", oldname, newname, underlyingError(err)}
+ }
+ return nil
+}
return nil
}
+func rootRename(r *Root, oldname, newname string) error {
+ _, err := doInRoot(r, oldname, func(oldparent sysfdType, oldname string) (struct{}, error) {
+ _, err := doInRoot(r, newname, func(newparent sysfdType, newname string) (struct{}, error) {
+ return struct{}{}, renameat(oldparent, oldname, newparent, newname)
+ })
+ return struct{}{}, err
+ })
+ if err != nil {
+ return &LinkError{"renameat", oldname, newname, err}
+ }
+ return err
+}
+
// doInRoot performs an operation on a path in a Root.
//
// It opens the directory containing the final element of the path,
}
}
+// TestRootRenameFrom tests renaming the test case target to a known-good path.
+func TestRootRenameFrom(t *testing.T) {
+ want := []byte("target")
+ for _, test := range rootTestCases {
+ test.run(t, func(t *testing.T, target string, root *os.Root) {
+ if target != "" {
+ if err := os.WriteFile(target, want, 0o666); err != nil {
+ t.Fatal(err)
+ }
+ }
+ wantError := test.wantError
+ var linkTarget string
+ if test.ltarget != "" {
+ // Rename will rename the link, not the file linked to.
+ wantError = false
+ var err error
+ linkTarget, err = root.Readlink(test.ltarget)
+ if err != nil {
+ t.Fatalf("root.Readlink(%q) = %v, want success", test.ltarget, err)
+ }
+ }
+
+ const dstPath = "destination"
+
+ // Plan 9 doesn't allow cross-directory renames.
+ if runtime.GOOS == "plan9" && strings.Contains(test.open, "/") {
+ wantError = true
+ }
+
+ err := root.Rename(test.open, dstPath)
+ if errEndsTest(t, err, wantError, "root.Rename(%q, %q)", test.open, dstPath) {
+ return
+ }
+
+ if test.ltarget != "" {
+ got, err := os.Readlink(filepath.Join(root.Name(), dstPath))
+ if err != nil || got != linkTarget {
+ t.Errorf("os.Readlink(%q) = %q, %v, want %q", dstPath, got, err, linkTarget)
+ }
+ } else {
+ got, err := os.ReadFile(filepath.Join(root.Name(), dstPath))
+ if err != nil || !bytes.Equal(got, want) {
+ t.Errorf(`os.ReadFile(%q): read content %q, %v; want %q`, dstPath, string(got), err, string(want))
+ }
+ }
+ })
+ }
+}
+
+// TestRootRenameTo tests renaming a known-good path to the test case target.
+func TestRootRenameTo(t *testing.T) {
+ want := []byte("target")
+ for _, test := range rootTestCases {
+ test.run(t, func(t *testing.T, target string, root *os.Root) {
+ const srcPath = "source"
+ if err := os.WriteFile(filepath.Join(root.Name(), srcPath), want, 0o666); err != nil {
+ t.Fatal(err)
+ }
+
+ target = test.target
+ wantError := test.wantError
+ if test.ltarget != "" {
+ // Rename will overwrite the final link rather than follow it.
+ target = test.ltarget
+ wantError = false
+ }
+
+ // Plan 9 doesn't allow cross-directory renames.
+ if runtime.GOOS == "plan9" && strings.Contains(test.open, "/") {
+ wantError = true
+ }
+
+ err := root.Rename(srcPath, test.open)
+ if errEndsTest(t, err, wantError, "root.Rename(%q, %q)", srcPath, test.open) {
+ return
+ }
+
+ got, err := os.ReadFile(filepath.Join(root.Name(), target))
+ if err != nil || !bytes.Equal(got, want) {
+ t.Errorf(`os.ReadFile(%q): read content %q, %v; want %q`, target, string(got), err, string(want))
+ }
+ })
+ }
+}
+
// A rootConsistencyTest is a test case comparing os.Root behavior with
// the corresponding non-Root function.
//
}
if err1 != nil || err2 != nil {
- e1, ok := err1.(*os.PathError)
- if !ok {
- t.Fatalf("with root, expected PathError; got: %v", err1)
- }
- e2, ok := err2.(*os.PathError)
- if !ok {
- t.Fatalf("without root, expected PathError; got: %v", err1)
+ underlyingError := func(how string, err error) error {
+ switch e := err1.(type) {
+ case *os.PathError:
+ return e.Err
+ case *os.LinkError:
+ return e.Err
+ default:
+ t.Fatalf("%v, expected PathError or LinkError; got: %v", how, err)
+ }
+ return nil
}
+ e1 := underlyingError("with root", err1)
+ e2 := underlyingError("without root", err1)
detailedErrorMismatch := false
if f := test.detailedErrorMismatch; f != nil {
detailedErrorMismatch = f(t)
// Plan9 syscall errors aren't comparable.
detailedErrorMismatch = true
}
- if !detailedErrorMismatch && e1.Err != e2.Err {
- t.Errorf("with root: err=%v", e1.Err)
- t.Errorf("without root: err=%v", e2.Err)
+ if !detailedErrorMismatch && e1 != e2 {
+ t.Errorf("with root: err=%v", e1)
+ t.Errorf("without root: err=%v", e2)
t.Errorf("want consistent results, got mismatch")
}
}
}
}
+func TestRootConsistencyRename(t *testing.T) {
+ if runtime.GOOS == "plan9" {
+ // This test depends on moving files between directories.
+ t.Skip("Plan 9 does not support cross-directory renames")
+ }
+ // Run this test in two directions:
+ // Renaming the test path to a known-good path (from),
+ // and renaming a known-good path to the test path (to).
+ for _, name := range []string{"from", "to"} {
+ t.Run(name, func(t *testing.T) {
+ for _, test := range rootConsistencyTestCases {
+ if runtime.GOOS == "windows" {
+ // On Windows, Rename("/path/to/.", x) succeeds,
+ // because Windows cleans the path to just "/path/to".
+ // Root.Rename(".", x) fails as expected.
+ // Don't run this consistency test on Windows.
+ if test.open == "." || test.open == "./" {
+ continue
+ }
+ }
+
+ test.run(t, func(t *testing.T, path string, r *os.Root) (string, error) {
+ rename := os.Rename
+ lstat := os.Lstat
+ if r != nil {
+ rename = r.Rename
+ lstat = r.Lstat
+ }
+
+ otherPath := "other"
+ if r == nil {
+ otherPath = filepath.Join(t.TempDir(), otherPath)
+ }
+
+ var srcPath, dstPath string
+ if name == "from" {
+ srcPath = path
+ dstPath = otherPath
+ } else {
+ srcPath = otherPath
+ dstPath = path
+ }
+
+ if err := rename(srcPath, dstPath); err != nil {
+ return "", err
+ }
+ fi, err := lstat(dstPath)
+ if err != nil {
+ t.Errorf("stat(%q) after successful copy: %v", dstPath, err)
+ return "stat error", err
+ }
+ return fmt.Sprintf("name:%q size:%v mode:%v isdir:%v", fi.Name(), fi.Size(), fi.Mode(), fi.IsDir()), nil
+ })
+ }
+ })
+ }
+}
+
func TestRootRenameAfterOpen(t *testing.T) {
switch runtime.GOOS {
case "windows":
return e
}
+func renameat(oldfd int, oldname string, newfd int, newname string) error {
+ return unix.Renameat(oldfd, oldname, newfd, newname)
+}
+
// checkSymlink resolves the symlink name in parent,
// and returns errSymlink with the link contents.
//
return syscall.SetFileTime(h, nil, &a, &w)
}
+func renameat(oldfd syscall.Handle, oldname string, newfd syscall.Handle, newname string) error {
+ return windows.Renameat(oldfd, oldname, newfd, newname)
+}
+
func readlinkat(dirfd syscall.Handle, name string) (string, error) {
fd, err := openat(dirfd, name, windows.O_OPEN_REPARSE, 0)
if err != nil {