| // Copyright 2015 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. |
| |
| package syscall_test |
| |
| import ( |
| "fmt" |
| "io" |
| "io/fs" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "runtime" |
| "sort" |
| "strconv" |
| "strings" |
| "sync" |
| "syscall" |
| "testing" |
| "unsafe" |
| ) |
| |
| // chtmpdir changes the working directory to a new temporary directory and |
| // provides a cleanup function. Used when PWD is read-only. |
| func chtmpdir(t *testing.T) func() { |
| oldwd, err := os.Getwd() |
| if err != nil { |
| t.Fatalf("chtmpdir: %v", err) |
| } |
| d, err := os.MkdirTemp("", "test") |
| if err != nil { |
| t.Fatalf("chtmpdir: %v", err) |
| } |
| if err := os.Chdir(d); err != nil { |
| t.Fatalf("chtmpdir: %v", err) |
| } |
| return func() { |
| if err := os.Chdir(oldwd); err != nil { |
| t.Fatalf("chtmpdir: %v", err) |
| } |
| os.RemoveAll(d) |
| } |
| } |
| |
| func touch(t *testing.T, name string) { |
| f, err := os.Create(name) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := f.Close(); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| const ( |
| _AT_SYMLINK_NOFOLLOW = 0x100 |
| _AT_FDCWD = -0x64 |
| _AT_EACCESS = 0x200 |
| _F_OK = 0 |
| _R_OK = 4 |
| ) |
| |
| func TestFaccessat(t *testing.T) { |
| defer chtmpdir(t)() |
| touch(t, "file1") |
| |
| err := syscall.Faccessat(_AT_FDCWD, "file1", _R_OK, 0) |
| if err != nil { |
| t.Errorf("Faccessat: unexpected error: %v", err) |
| } |
| |
| err = syscall.Faccessat(_AT_FDCWD, "file1", _R_OK, 2) |
| if err != syscall.EINVAL { |
| t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err) |
| } |
| |
| err = syscall.Faccessat(_AT_FDCWD, "file1", _R_OK, _AT_EACCESS) |
| if err != nil { |
| t.Errorf("Faccessat: unexpected error: %v", err) |
| } |
| |
| err = os.Symlink("file1", "symlink1") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| err = syscall.Faccessat(_AT_FDCWD, "symlink1", _R_OK, _AT_SYMLINK_NOFOLLOW) |
| if err != nil { |
| t.Errorf("Faccessat SYMLINK_NOFOLLOW: unexpected error %v", err) |
| } |
| |
| // We can't really test _AT_SYMLINK_NOFOLLOW, because there |
| // doesn't seem to be any way to change the mode of a symlink. |
| // We don't test _AT_EACCESS because such tests are only |
| // meaningful if run as root. |
| |
| err = syscall.Fchmodat(_AT_FDCWD, "file1", 0, 0) |
| if err != nil { |
| t.Errorf("Fchmodat: unexpected error %v", err) |
| } |
| |
| err = syscall.Faccessat(_AT_FDCWD, "file1", _F_OK, _AT_SYMLINK_NOFOLLOW) |
| if err != nil { |
| t.Errorf("Faccessat: unexpected error: %v", err) |
| } |
| |
| err = syscall.Faccessat(_AT_FDCWD, "file1", _R_OK, _AT_SYMLINK_NOFOLLOW) |
| if err != syscall.EACCES { |
| if syscall.Getuid() != 0 { |
| t.Errorf("Faccessat: unexpected error: %v, want EACCES", err) |
| } |
| } |
| } |
| |
| func TestFchmodat(t *testing.T) { |
| defer chtmpdir(t)() |
| |
| touch(t, "file1") |
| os.Symlink("file1", "symlink1") |
| |
| err := syscall.Fchmodat(_AT_FDCWD, "symlink1", 0444, 0) |
| if err != nil { |
| t.Fatalf("Fchmodat: unexpected error: %v", err) |
| } |
| |
| fi, err := os.Stat("file1") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if fi.Mode() != 0444 { |
| t.Errorf("Fchmodat: failed to change mode: expected %v, got %v", 0444, fi.Mode()) |
| } |
| |
| err = syscall.Fchmodat(_AT_FDCWD, "symlink1", 0444, _AT_SYMLINK_NOFOLLOW) |
| if err != syscall.EOPNOTSUPP { |
| t.Fatalf("Fchmodat: unexpected error: %v, expected EOPNOTSUPP", err) |
| } |
| } |
| |
| func TestMain(m *testing.M) { |
| if os.Getenv("GO_DEATHSIG_PARENT") == "1" { |
| deathSignalParent() |
| } else if os.Getenv("GO_DEATHSIG_CHILD") == "1" { |
| deathSignalChild() |
| } else if os.Getenv("GO_SYSCALL_NOERROR") == "1" { |
| syscallNoError() |
| } |
| |
| os.Exit(m.Run()) |
| } |
| |
| func TestParseNetlinkMessage(t *testing.T) { |
| for i, b := range [][]byte{ |
| {103, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 11, 0, 1, 0, 0, 0, 0, 5, 8, 0, 3, |
| 0, 8, 0, 6, 0, 0, 0, 0, 1, 63, 0, 10, 0, 69, 16, 0, 59, 39, 82, 64, 0, 64, 6, 21, 89, 127, 0, 0, |
| 1, 127, 0, 0, 1, 230, 228, 31, 144, 32, 186, 155, 211, 185, 151, 209, 179, 128, 24, 1, 86, |
| 53, 119, 0, 0, 1, 1, 8, 10, 0, 17, 234, 12, 0, 17, 189, 126, 107, 106, 108, 107, 106, 13, 10, |
| }, |
| {106, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 11, 0, 1, 0, 0, 0, 0, 3, 8, 0, 3, |
| 0, 8, 0, 6, 0, 0, 0, 0, 1, 66, 0, 10, 0, 69, 0, 0, 62, 230, 255, 64, 0, 64, 6, 85, 184, 127, 0, 0, |
| 1, 127, 0, 0, 1, 237, 206, 31, 144, 73, 197, 128, 65, 250, 60, 192, 97, 128, 24, 1, 86, 253, 21, 0, |
| 0, 1, 1, 8, 10, 0, 51, 106, 89, 0, 51, 102, 198, 108, 104, 106, 108, 107, 104, 108, 107, 104, 10, |
| }, |
| {102, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 11, 0, 1, 0, 0, 0, 0, 1, 8, 0, 3, 0, |
| 8, 0, 6, 0, 0, 0, 0, 1, 62, 0, 10, 0, 69, 0, 0, 58, 231, 2, 64, 0, 64, 6, 85, 185, 127, 0, 0, 1, 127, |
| 0, 0, 1, 237, 206, 31, 144, 73, 197, 128, 86, 250, 60, 192, 97, 128, 24, 1, 86, 104, 64, 0, 0, 1, 1, 8, |
| 10, 0, 52, 198, 200, 0, 51, 135, 232, 101, 115, 97, 103, 103, 10, |
| }, |
| } { |
| m, err := syscall.ParseNetlinkMessage(b) |
| if err != syscall.EINVAL { |
| t.Errorf("#%d: got %v; want EINVAL", i, err) |
| } |
| if m != nil { |
| t.Errorf("#%d: got %v; want nil", i, m) |
| } |
| } |
| } |
| |
| func TestSyscallNoError(t *testing.T) { |
| // On Linux there are currently no syscalls which don't fail and return |
| // a value larger than 0xfffffffffffff001 so we could test RawSyscall |
| // vs. RawSyscallNoError on 64bit architectures. |
| if unsafe.Sizeof(uintptr(0)) != 4 { |
| t.Skip("skipping on non-32bit architecture") |
| } |
| |
| // See https://golang.org/issue/35422 |
| // On MIPS, Linux returns whether the syscall had an error in a separate |
| // register (R7), not using a negative return value as on other |
| // architectures. |
| if runtime.GOARCH == "mips" || runtime.GOARCH == "mipsle" { |
| t.Skipf("skipping on %s", runtime.GOARCH) |
| } |
| |
| if os.Getuid() != 0 { |
| t.Skip("skipping root only test") |
| } |
| |
| if syscall.Sys_GETEUID == 0 { |
| t.Skip("skipping because there is no geteuid system call") |
| } |
| |
| if runtime.GOOS == "android" { |
| t.Skip("skipping on rooted android, see issue 27364") |
| } |
| |
| // Copy the test binary to a location that a non-root user can read/execute |
| // after we drop privileges |
| tempDir, err := os.MkdirTemp("", "TestSyscallNoError") |
| if err != nil { |
| t.Fatalf("cannot create temporary directory: %v", err) |
| } |
| defer os.RemoveAll(tempDir) |
| os.Chmod(tempDir, 0755) |
| |
| tmpBinary := filepath.Join(tempDir, filepath.Base(os.Args[0])) |
| |
| src, err := os.Open(os.Args[0]) |
| if err != nil { |
| t.Fatalf("cannot open binary %q, %v", os.Args[0], err) |
| } |
| defer src.Close() |
| |
| dst, err := os.OpenFile(tmpBinary, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755) |
| if err != nil { |
| t.Fatalf("cannot create temporary binary %q, %v", tmpBinary, err) |
| } |
| if _, err := io.Copy(dst, src); err != nil { |
| t.Fatalf("failed to copy test binary to %q, %v", tmpBinary, err) |
| } |
| err = dst.Close() |
| if err != nil { |
| t.Fatalf("failed to close test binary %q, %v", tmpBinary, err) |
| } |
| |
| uid := uint32(0xfffffffe) |
| err = os.Chown(tmpBinary, int(uid), -1) |
| if err != nil { |
| t.Fatalf("failed to chown test binary %q, %v", tmpBinary, err) |
| } |
| |
| err = os.Chmod(tmpBinary, 0755|fs.ModeSetuid) |
| if err != nil { |
| t.Fatalf("failed to set setuid bit on test binary %q, %v", tmpBinary, err) |
| } |
| |
| cmd := exec.Command(tmpBinary) |
| cmd.Env = append(os.Environ(), "GO_SYSCALL_NOERROR=1") |
| |
| out, err := cmd.CombinedOutput() |
| if err != nil { |
| t.Fatalf("failed to start first child process: %v", err) |
| } |
| |
| got := strings.TrimSpace(string(out)) |
| want := strconv.FormatUint(uint64(uid)+1, 10) + " / " + |
| strconv.FormatUint(uint64(-uid), 10) + " / " + |
| strconv.FormatUint(uint64(uid), 10) |
| if got != want { |
| if filesystemIsNoSUID(tmpBinary) { |
| t.Skip("skipping test when temp dir is mounted nosuid") |
| } |
| // formatted so the values are aligned for easier comparison |
| t.Errorf("expected %s,\ngot %s", want, got) |
| } |
| } |
| |
| // filesystemIsNoSUID reports whether the filesystem for the given |
| // path is mounted nosuid. |
| func filesystemIsNoSUID(path string) bool { |
| var st syscall.Statfs_t |
| if syscall.Statfs(path, &st) != nil { |
| return false |
| } |
| return st.Flags&syscall.MS_NOSUID != 0 |
| } |
| |
| func syscallNoError() { |
| // Test that the return value from SYS_GETEUID32 (which cannot fail) |
| // doesn't get treated as an error (see https://golang.org/issue/22924) |
| euid1, _, e := syscall.RawSyscall(syscall.Sys_GETEUID, 0, 0, 0) |
| euid2, _ := syscall.RawSyscallNoError(syscall.Sys_GETEUID, 0, 0, 0) |
| |
| fmt.Println(uintptr(euid1), "/", int(e), "/", uintptr(euid2)) |
| os.Exit(0) |
| } |
| |
| // reference uapi/linux/prctl.h |
| const ( |
| PR_GET_KEEPCAPS uintptr = 7 |
| PR_SET_KEEPCAPS = 8 |
| ) |
| |
| // TestAllThreadsSyscall tests that the go runtime can perform |
| // syscalls that execute on all OSThreads - with which to support |
| // POSIX semantics for security state changes. |
| func TestAllThreadsSyscall(t *testing.T) { |
| if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, PR_SET_KEEPCAPS, 0, 0); err == syscall.ENOTSUP { |
| t.Skip("AllThreadsSyscall disabled with cgo") |
| } |
| |
| fns := []struct { |
| label string |
| fn func(uintptr) error |
| }{ |
| { |
| label: "prctl<3-args>", |
| fn: func(v uintptr) error { |
| _, _, e := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, PR_SET_KEEPCAPS, v, 0) |
| if e != 0 { |
| return e |
| } |
| return nil |
| }, |
| }, |
| { |
| label: "prctl<6-args>", |
| fn: func(v uintptr) error { |
| _, _, e := syscall.AllThreadsSyscall6(syscall.SYS_PRCTL, PR_SET_KEEPCAPS, v, 0, 0, 0, 0) |
| if e != 0 { |
| return e |
| } |
| return nil |
| }, |
| }, |
| } |
| |
| waiter := func(q <-chan uintptr, r chan<- uintptr, once bool) { |
| for x := range q { |
| runtime.LockOSThread() |
| v, _, e := syscall.Syscall(syscall.SYS_PRCTL, PR_GET_KEEPCAPS, 0, 0) |
| if e != 0 { |
| t.Errorf("tid=%d prctl(PR_GET_KEEPCAPS) failed: %v", syscall.Gettid(), e) |
| } else if x != v { |
| t.Errorf("tid=%d prctl(PR_GET_KEEPCAPS) mismatch: got=%d want=%d", syscall.Gettid(), v, x) |
| } |
| r <- v |
| if once { |
| break |
| } |
| runtime.UnlockOSThread() |
| } |
| } |
| |
| // launches per fns member. |
| const launches = 11 |
| question := make(chan uintptr) |
| response := make(chan uintptr) |
| defer close(question) |
| |
| routines := 0 |
| for i, v := range fns { |
| for j := 0; j < launches; j++ { |
| // Add another goroutine - the closest thing |
| // we can do to encourage more OS thread |
| // creation - while the test is running. The |
| // actual thread creation may or may not be |
| // needed, based on the number of available |
| // unlocked OS threads at the time waiter |
| // calls runtime.LockOSThread(), but the goal |
| // of doing this every time through the loop |
| // is to race thread creation with v.fn(want) |
| // being executed. Via the once boolean we |
| // also encourage one in 5 waiters to return |
| // locked after participating in only one |
| // question response sequence. This allows the |
| // test to race thread destruction too. |
| once := routines%5 == 4 |
| go waiter(question, response, once) |
| |
| // Keep a count of how many goroutines are |
| // going to participate in the |
| // question/response test. This will count up |
| // towards 2*launches minus the count of |
| // routines that have been invoked with |
| // once=true. |
| routines++ |
| |
| // Decide what value we want to set the |
| // process-shared KEEPCAPS. Note, there is |
| // an explicit repeat of 0 when we change the |
| // variant of the syscall being used. |
| want := uintptr(j & 1) |
| |
| // Invoke the AllThreadsSyscall* variant. |
| if err := v.fn(want); err != nil { |
| t.Errorf("[%d,%d] %s(PR_SET_KEEPCAPS, %d, ...): %v", i, j, v.label, j&1, err) |
| } |
| |
| // At this point, we want all launched Go |
| // routines to confirm that they see the |
| // wanted value for KEEPCAPS. |
| for k := 0; k < routines; k++ { |
| question <- want |
| } |
| |
| // At this point, we should have a large |
| // number of locked OS threads all wanting to |
| // reply. |
| for k := 0; k < routines; k++ { |
| if got := <-response; got != want { |
| t.Errorf("[%d,%d,%d] waiter result got=%d, want=%d", i, j, k, got, want) |
| } |
| } |
| |
| // Provide an explicit opportunity for this Go |
| // routine to change Ms. |
| runtime.Gosched() |
| |
| if once { |
| // One waiter routine will have exited. |
| routines-- |
| } |
| |
| // Whatever M we are now running on, confirm |
| // we see the wanted value too. |
| if v, _, e := syscall.Syscall(syscall.SYS_PRCTL, PR_GET_KEEPCAPS, 0, 0); e != 0 { |
| t.Errorf("[%d,%d] prctl(PR_GET_KEEPCAPS) failed: %v", i, j, e) |
| } else if v != want { |
| t.Errorf("[%d,%d] prctl(PR_GET_KEEPCAPS) gave wrong value: got=%v, want=1", i, j, v) |
| } |
| } |
| } |
| } |
| |
| // compareStatus is used to confirm the contents of the thread |
| // specific status files match expectations. |
| func compareStatus(filter, expect string) error { |
| expected := filter + expect |
| pid := syscall.Getpid() |
| fs, err := os.ReadDir(fmt.Sprintf("/proc/%d/task", pid)) |
| if err != nil { |
| return fmt.Errorf("unable to find %d tasks: %v", pid, err) |
| } |
| expectedProc := fmt.Sprintf("Pid:\t%d", pid) |
| foundAThread := false |
| for _, f := range fs { |
| tf := fmt.Sprintf("/proc/%s/status", f.Name()) |
| d, err := os.ReadFile(tf) |
| if err != nil { |
| // There are a surprising number of ways this |
| // can error out on linux. We've seen all of |
| // the following, so treat any error here as |
| // equivalent to the "process is gone": |
| // os.IsNotExist(err), |
| // "... : no such process", |
| // "... : bad file descriptor. |
| continue |
| } |
| lines := strings.Split(string(d), "\n") |
| for _, line := range lines { |
| // Different kernel vintages pad differently. |
| line = strings.TrimSpace(line) |
| if strings.HasPrefix(line, "Pid:\t") { |
| // On loaded systems, it is possible |
| // for a TID to be reused really |
| // quickly. As such, we need to |
| // validate that the thread status |
| // info we just read is a task of the |
| // same process PID as we are |
| // currently running, and not a |
| // recently terminated thread |
| // resurfaced in a different process. |
| if line != expectedProc { |
| break |
| } |
| // Fall through in the unlikely case |
| // that filter at some point is |
| // "Pid:\t". |
| } |
| if strings.HasPrefix(line, filter) { |
| if line == expected { |
| foundAThread = true |
| break |
| } |
| if filter == "Groups:" && strings.HasPrefix(line, "Groups:\t") { |
| // https://github.com/golang/go/issues/46145 |
| // Containers don't reliably output this line in sorted order so manually sort and compare that. |
| a := strings.Split(line[8:], " ") |
| sort.Strings(a) |
| got := strings.Join(a, " ") |
| if got == expected[8:] { |
| foundAThread = true |
| break |
| } |
| |
| } |
| return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc) |
| } |
| } |
| } |
| if !foundAThread { |
| return fmt.Errorf("found no thread /proc/<TID>/status files for process %q", expectedProc) |
| } |
| return nil |
| } |
| |
| // killAThread locks the goroutine to an OS thread and exits; this |
| // causes an OS thread to terminate. |
| func killAThread(c <-chan struct{}) { |
| runtime.LockOSThread() |
| <-c |
| return |
| } |
| |
| // TestSetuidEtc performs tests on all of the wrapped system calls |
| // that mirror to the 9 glibc syscalls with POSIX semantics. The test |
| // here is considered authoritative and should compile and run |
| // CGO_ENABLED=0 or 1. Note, there is an extended copy of this same |
| // test in ../../misc/cgo/test/issue1435.go which requires |
| // CGO_ENABLED=1 and launches pthreads from C that run concurrently |
| // with the Go code of the test - and the test validates that these |
| // pthreads are also kept in sync with the security state changed with |
| // the syscalls. Care should be taken to mirror any enhancements to |
| // this test here in that file too. |
| func TestSetuidEtc(t *testing.T) { |
| if syscall.Getuid() != 0 { |
| t.Skip("skipping root only test") |
| } |
| vs := []struct { |
| call string |
| fn func() error |
| filter, expect string |
| }{ |
| {call: "Setegid(1)", fn: func() error { return syscall.Setegid(1) }, filter: "Gid:", expect: "\t0\t1\t0\t1"}, |
| {call: "Setegid(0)", fn: func() error { return syscall.Setegid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Seteuid(1)", fn: func() error { return syscall.Seteuid(1) }, filter: "Uid:", expect: "\t0\t1\t0\t1"}, |
| {call: "Setuid(0)", fn: func() error { return syscall.Setuid(0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Setgid(1)", fn: func() error { return syscall.Setgid(1) }, filter: "Gid:", expect: "\t1\t1\t1\t1"}, |
| {call: "Setgid(0)", fn: func() error { return syscall.Setgid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Setgroups([]int{0,1,2,3})", fn: func() error { return syscall.Setgroups([]int{0, 1, 2, 3}) }, filter: "Groups:", expect: "\t0 1 2 3"}, |
| {call: "Setgroups(nil)", fn: func() error { return syscall.Setgroups(nil) }, filter: "Groups:", expect: ""}, |
| {call: "Setgroups([]int{0})", fn: func() error { return syscall.Setgroups([]int{0}) }, filter: "Groups:", expect: "\t0"}, |
| |
| {call: "Setregid(101,0)", fn: func() error { return syscall.Setregid(101, 0) }, filter: "Gid:", expect: "\t101\t0\t0\t0"}, |
| {call: "Setregid(0,102)", fn: func() error { return syscall.Setregid(0, 102) }, filter: "Gid:", expect: "\t0\t102\t102\t102"}, |
| {call: "Setregid(0,0)", fn: func() error { return syscall.Setregid(0, 0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Setreuid(1,0)", fn: func() error { return syscall.Setreuid(1, 0) }, filter: "Uid:", expect: "\t1\t0\t0\t0"}, |
| {call: "Setreuid(0,2)", fn: func() error { return syscall.Setreuid(0, 2) }, filter: "Uid:", expect: "\t0\t2\t2\t2"}, |
| {call: "Setreuid(0,0)", fn: func() error { return syscall.Setreuid(0, 0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Setresgid(101,0,102)", fn: func() error { return syscall.Setresgid(101, 0, 102) }, filter: "Gid:", expect: "\t101\t0\t102\t0"}, |
| {call: "Setresgid(0,102,101)", fn: func() error { return syscall.Setresgid(0, 102, 101) }, filter: "Gid:", expect: "\t0\t102\t101\t102"}, |
| {call: "Setresgid(0,0,0)", fn: func() error { return syscall.Setresgid(0, 0, 0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"}, |
| |
| {call: "Setresuid(1,0,2)", fn: func() error { return syscall.Setresuid(1, 0, 2) }, filter: "Uid:", expect: "\t1\t0\t2\t0"}, |
| {call: "Setresuid(0,2,1)", fn: func() error { return syscall.Setresuid(0, 2, 1) }, filter: "Uid:", expect: "\t0\t2\t1\t2"}, |
| {call: "Setresuid(0,0,0)", fn: func() error { return syscall.Setresuid(0, 0, 0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"}, |
| } |
| |
| for i, v := range vs { |
| // Generate some thread churn as we execute the tests. |
| c := make(chan struct{}) |
| go killAThread(c) |
| close(c) |
| |
| if err := v.fn(); err != nil { |
| t.Errorf("[%d] %q failed: %v", i, v.call, err) |
| continue |
| } |
| if err := compareStatus(v.filter, v.expect); err != nil { |
| t.Errorf("[%d] %q comparison: %v", i, v.call, err) |
| } |
| } |
| } |
| |
| // TestAllThreadsSyscallError verifies that errors are properly returned when |
| // the syscall fails on the original thread. |
| func TestAllThreadsSyscallError(t *testing.T) { |
| // SYS_CAPGET takes pointers as the first two arguments. Since we pass |
| // 0, we expect to get EFAULT back. |
| r1, r2, err := syscall.AllThreadsSyscall(syscall.SYS_CAPGET, 0, 0, 0) |
| if err == syscall.ENOTSUP { |
| t.Skip("AllThreadsSyscall disabled with cgo") |
| } |
| if err != syscall.EFAULT { |
| t.Errorf("AllThreadSyscall(SYS_CAPGET) got %d, %d, %v, want err %v", r1, r2, err, syscall.EFAULT) |
| } |
| } |
| |
| // TestAllThreadsSyscallBlockedSyscall confirms that AllThreadsSyscall |
| // can interrupt threads in long-running system calls. This test will |
| // deadlock if this doesn't work correctly. |
| func TestAllThreadsSyscallBlockedSyscall(t *testing.T) { |
| if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, PR_SET_KEEPCAPS, 0, 0); err == syscall.ENOTSUP { |
| t.Skip("AllThreadsSyscall disabled with cgo") |
| } |
| |
| rd, wr, err := os.Pipe() |
| if err != nil { |
| t.Fatalf("unable to obtain a pipe: %v", err) |
| } |
| |
| // Perform a blocking read on the pipe. |
| var wg sync.WaitGroup |
| ready := make(chan bool) |
| wg.Add(1) |
| go func() { |
| data := make([]byte, 1) |
| |
| // To narrow the window we have to wait for this |
| // goroutine to block in read, synchronize just before |
| // calling read. |
| ready <- true |
| |
| // We use syscall.Read directly to avoid the poller. |
| // This will return when the write side is closed. |
| n, err := syscall.Read(int(rd.Fd()), data) |
| if !(n == 0 && err == nil) { |
| t.Errorf("expected read to return 0, got %d, %s", n, err) |
| } |
| |
| // Clean up rd and also ensure rd stays reachable so |
| // it doesn't get closed by GC. |
| rd.Close() |
| wg.Done() |
| }() |
| <-ready |
| |
| // Loop here to give the goroutine more time to block in read. |
| // Generally this will trigger on the first iteration anyway. |
| pid := syscall.Getpid() |
| for i := 0; i < 100; i++ { |
| if id, _, e := syscall.AllThreadsSyscall(syscall.SYS_GETPID, 0, 0, 0); e != 0 { |
| t.Errorf("[%d] getpid failed: %v", i, e) |
| } else if int(id) != pid { |
| t.Errorf("[%d] getpid got=%d, want=%d", i, id, pid) |
| } |
| // Provide an explicit opportunity for this goroutine |
| // to change Ms. |
| runtime.Gosched() |
| } |
| wr.Close() |
| wg.Wait() |
| } |