diff options
Diffstat (limited to 'src/os')
| -rw-r--r-- | src/os/root.go | 7 | ||||
| -rw-r--r-- | src/os/root_noopenat.go | 14 | ||||
| -rw-r--r-- | src/os/root_openat.go | 13 | ||||
| -rw-r--r-- | src/os/root_test.go | 168 | ||||
| -rw-r--r-- | src/os/root_unix.go | 4 | ||||
| -rw-r--r-- | src/os/root_windows.go | 4 |
6 files changed, 200 insertions, 10 deletions
diff --git a/src/os/root.go b/src/os/root.go index fcb4600739..55ccd20478 100644 --- a/src/os/root.go +++ b/src/os/root.go @@ -199,6 +199,13 @@ func (r *Root) Readlink(name string) (string, error) { 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, diff --git a/src/os/root_noopenat.go b/src/os/root_noopenat.go index f0e1aa5131..4a4aa684af 100644 --- a/src/os/root_noopenat.go +++ b/src/os/root_noopenat.go @@ -166,3 +166,17 @@ func rootReadlink(r *Root, name string) (string, error) { } 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 +} diff --git a/src/os/root_openat.go b/src/os/root_openat.go index 8c07784b5a..2cb867459b 100644 --- a/src/os/root_openat.go +++ b/src/os/root_openat.go @@ -138,6 +138,19 @@ func rootRemove(r *Root, name string) error { 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, diff --git a/src/os/root_test.go b/src/os/root_test.go index 4ca6f9c834..5ed8fe0146 100644 --- a/src/os/root_test.go +++ b/src/os/root_test.go @@ -699,6 +699,91 @@ func TestRootReadlink(t *testing.T) { } } +// 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. // @@ -927,14 +1012,19 @@ func (test rootConsistencyTest) run(t *testing.T, f func(t *testing.T, path stri } 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) @@ -943,9 +1033,9 @@ func (test rootConsistencyTest) run(t *testing.T, f func(t *testing.T, path stri // 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") } } @@ -1110,6 +1200,64 @@ func TestRootConsistencyReadlink(t *testing.T) { } } +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": diff --git a/src/os/root_unix.go b/src/os/root_unix.go index a5ca10b0cd..dc22651423 100644 --- a/src/os/root_unix.go +++ b/src/os/root_unix.go @@ -209,6 +209,10 @@ func removeat(fd int, name string) error { 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. // diff --git a/src/os/root_windows.go b/src/os/root_windows.go index 81fc5c320c..f4d2f4152b 100644 --- a/src/os/root_windows.go +++ b/src/os/root_windows.go @@ -315,6 +315,10 @@ func chtimesat(dirfd syscall.Handle, name string, atime time.Time, mtime time.Ti 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 { |