github.com/Kalvelign/golang-windows-sys-lib@v0.0.0-20221121121202-63da651435e1/unix/syscall_linux_test.go (about) 1 // Copyright 2016 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build linux 6 // +build linux 7 8 package unix_test 9 10 import ( 11 "bufio" 12 "bytes" 13 "errors" 14 "fmt" 15 "io/ioutil" 16 "net" 17 "os" 18 "os/exec" 19 "path/filepath" 20 "runtime" 21 "runtime/debug" 22 "strconv" 23 "strings" 24 "syscall" 25 "testing" 26 "time" 27 "unsafe" 28 29 "golang.org/x/sys/unix" 30 ) 31 32 func TestIoctlGetEthtoolDrvinfo(t *testing.T) { 33 if runtime.GOOS == "android" { 34 t.Skip("ethtool driver info is not available on android, skipping test") 35 } 36 37 s, err := unix.Socket(unix.AF_INET, unix.SOCK_STREAM, 0) 38 if err != nil { 39 t.Fatalf("failed to open socket: %v", err) 40 } 41 defer unix.Close(s) 42 43 ifis, err := net.Interfaces() 44 if err != nil { 45 t.Fatalf("failed to get network interfaces: %v", err) 46 } 47 48 // Print the interface name and associated driver information for each 49 // network interface supported by ethtool. 50 for _, ifi := range ifis { 51 drv, err := unix.IoctlGetEthtoolDrvinfo(s, ifi.Name) 52 if err != nil { 53 if err == unix.EOPNOTSUPP { 54 continue 55 } 56 57 t.Fatalf("failed to get ethtool driver info for %q: %v", ifi.Name, err) 58 } 59 60 // Trim trailing NULLs. 61 t.Logf("%s: %q", ifi.Name, string(bytes.TrimRight(drv.Driver[:], "\x00"))) 62 } 63 } 64 65 func TestIoctlGetInt(t *testing.T) { 66 f, err := os.Open("/dev/random") 67 if err != nil { 68 t.Fatalf("failed to open device: %v", err) 69 } 70 defer f.Close() 71 72 v, err := unix.IoctlGetInt(int(f.Fd()), unix.RNDGETENTCNT) 73 if err != nil { 74 t.Fatalf("failed to perform ioctl: %v", err) 75 } 76 77 t.Logf("%d bits of entropy available", v) 78 } 79 80 func TestIoctlRetInt(t *testing.T) { 81 f, err := os.Open("/proc/self/ns/mnt") 82 if err != nil { 83 t.Skipf("skipping test, %v", err) 84 } 85 defer f.Close() 86 87 v, err := unix.IoctlRetInt(int(f.Fd()), unix.NS_GET_NSTYPE) 88 if err != nil { 89 if err == unix.ENOTTY { 90 t.Skipf("old kernel? (need Linux >= 4.11)") 91 } 92 t.Fatalf("failed to perform ioctl: %v", err) 93 } 94 if v != unix.CLONE_NEWNS { 95 t.Fatalf("unexpected return from ioctl; expected %v, got %v", v, unix.CLONE_NEWNS) 96 } 97 } 98 99 func TestIoctlGetRTCTime(t *testing.T) { 100 f, err := os.Open("/dev/rtc0") 101 if err != nil { 102 t.Skipf("skipping test, %v", err) 103 } 104 defer f.Close() 105 106 v, err := unix.IoctlGetRTCTime(int(f.Fd())) 107 if err != nil { 108 t.Fatalf("failed to perform ioctl: %v", err) 109 } 110 111 t.Logf("RTC time: %04d-%02d-%02d %02d:%02d:%02d", v.Year+1900, v.Mon+1, v.Mday, v.Hour, v.Min, v.Sec) 112 } 113 114 func TestIoctlGetRTCWkAlrm(t *testing.T) { 115 f, err := os.Open("/dev/rtc0") 116 if err != nil { 117 t.Skipf("skipping test, %v", err) 118 } 119 defer f.Close() 120 121 v, err := unix.IoctlGetRTCWkAlrm(int(f.Fd())) 122 123 // Not all RTC drivers support wakeup alarms, and will return EINVAL in such cases. 124 if err == unix.EINVAL { 125 t.Skip("RTC_WKALM_RD ioctl not supported on this rtc, skipping test") 126 } 127 128 if err != nil { 129 t.Fatalf("failed to perform ioctl: %v", err) 130 } 131 132 t.Logf("RTC wake alarm enabled '%d'; time: %04d-%02d-%02d %02d:%02d:%02d", 133 v.Enabled, v.Time.Year+1900, v.Time.Mon+1, v.Time.Mday, v.Time.Hour, v.Time.Min, v.Time.Sec) 134 } 135 136 func TestIoctlIfreq(t *testing.T) { 137 s, err := unix.Socket(unix.AF_INET, unix.SOCK_STREAM, 0) 138 if err != nil { 139 t.Fatalf("failed to open socket: %v", err) 140 } 141 defer unix.Close(s) 142 143 ifis, err := net.Interfaces() 144 if err != nil { 145 t.Fatalf("failed to get network interfaces: %v", err) 146 } 147 148 // Compare the network interface fetched from rtnetlink with the data from 149 // the equivalent ioctl API. 150 for _, ifi := range ifis { 151 ifr, err := unix.NewIfreq(ifi.Name) 152 if err != nil { 153 t.Fatalf("failed to create ifreq for %q: %v", ifi.Name, err) 154 } 155 156 if err := unix.IoctlIfreq(s, unix.SIOCGIFINDEX, ifr); err != nil { 157 t.Fatalf("failed to get interface index for %q: %v", ifi.Name, err) 158 } 159 160 if want, got := ifi.Index, int(ifr.Uint32()); want != got { 161 t.Fatalf("unexpected interface index for %q: got: %d, want: %d", 162 ifi.Name, got, want) 163 } 164 165 if want, got := ifi.Name, ifr.Name(); want != got { 166 t.Fatalf("unexpected interface name for index %d: got: %q, want: %q", 167 ifi.Index, got, want) 168 } 169 170 wantIP, ok := firstIPv4(t, &ifi) 171 if err := unix.IoctlIfreq(s, unix.SIOCGIFADDR, ifr); err != nil { 172 // Interface may have no assigned IPv4 address. 173 if err != unix.EADDRNOTAVAIL { 174 t.Fatalf("failed to get IPv4 address for %q: %v", ifi.Name, err) 175 } 176 177 // But if we found an address via rtnetlink, we should expect the 178 // ioctl to return one. 179 if ok { 180 t.Fatalf("found IPv4 address %q for %q but ioctl returned none", wantIP, ifi.Name) 181 } 182 183 continue 184 } 185 186 // Found an address, compare it directly. 187 addr, err := ifr.Inet4Addr() 188 if err != nil { 189 t.Fatalf("failed to get ifreq IPv4 address: %v", err) 190 } 191 192 if want, got := wantIP, addr; !want.Equal(got) { 193 t.Fatalf("unexpected first IPv4 address for %q: got: %q, want: %q", 194 ifi.Name, got, want) 195 } 196 } 197 } 198 199 // firstIPv4 reports whether the interface has an IPv4 address assigned, 200 // returning the first discovered address. 201 func firstIPv4(t *testing.T, ifi *net.Interface) (net.IP, bool) { 202 t.Helper() 203 204 addrs, err := ifi.Addrs() 205 if err != nil { 206 t.Fatalf("failed to get interface %q addresses: %v", ifi.Name, err) 207 } 208 209 for _, a := range addrs { 210 // Only want valid IPv4 addresses. 211 ipn, ok := a.(*net.IPNet) 212 if !ok || ipn.IP.To4() == nil { 213 continue 214 } 215 216 return ipn.IP, true 217 } 218 219 return nil, false 220 } 221 222 func TestPidfd(t *testing.T) { 223 // Start a child process which will sleep for 1 hour; longer than the 10 224 // minute default Go test timeout. 225 cmd := exec.Command("sleep", "1h") 226 if err := cmd.Start(); err != nil { 227 t.Fatalf("failed to exec sleep: %v", err) 228 } 229 230 fd, err := unix.PidfdOpen(cmd.Process.Pid, 0) 231 if err != nil { 232 // GOARCH arm/arm64 and GOOS android builders do not support pidfds. 233 if errors.Is(err, unix.ENOSYS) { 234 t.Skipf("skipping, pidfd_open is not implemented: %v", err) 235 } 236 237 t.Fatalf("failed to open child pidfd: %v", err) 238 } 239 defer unix.Close(fd) 240 241 // Child is running but not terminated. 242 if err := unix.Waitid(unix.P_PIDFD, fd, nil, unix.WEXITED|unix.WNOHANG, nil); err != nil { 243 if errors.Is(err, unix.EINVAL) { 244 t.Skip("skipping due to waitid EINVAL, see https://go.dev/issues/52014") 245 } 246 247 t.Fatalf("failed to check for child exit: %v", err) 248 } 249 250 const want = unix.SIGHUP 251 if err := unix.PidfdSendSignal(fd, want, nil, 0); err != nil { 252 t.Fatalf("failed to signal child process: %v", err) 253 } 254 255 // Now verify that the child process received the expected signal. 256 var eerr *exec.ExitError 257 if err := cmd.Wait(); !errors.As(err, &eerr) { 258 t.Fatalf("child process terminated but did not return an exit error: %v", err) 259 } 260 261 if err := unix.Waitid(unix.P_PIDFD, fd, nil, unix.WEXITED, nil); !errors.Is(err, unix.ECHILD) { 262 t.Fatalf("expected ECHILD for final waitid, but got: %v", err) 263 } 264 265 ws, ok := eerr.Sys().(syscall.WaitStatus) 266 if !ok { 267 t.Fatalf("expected syscall.WaitStatus value, but got: %#T", eerr.Sys()) 268 } 269 270 if got := ws.Signal(); got != want { 271 t.Fatalf("unexpected child exit signal, got: %s, want: %s", got, want) 272 } 273 } 274 275 func TestPpoll(t *testing.T) { 276 if runtime.GOOS == "android" { 277 t.Skip("mkfifo syscall is not available on android, skipping test") 278 } 279 280 defer chtmpdir(t)() 281 f, cleanup := mktmpfifo(t) 282 defer cleanup() 283 284 const timeout = 100 * time.Millisecond 285 286 ok := make(chan bool, 1) 287 go func() { 288 select { 289 case <-time.After(10 * timeout): 290 t.Errorf("Ppoll: failed to timeout after %d", 10*timeout) 291 case <-ok: 292 } 293 }() 294 295 fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}} 296 timeoutTs := unix.NsecToTimespec(int64(timeout)) 297 n, err := unix.Ppoll(fds, &timeoutTs, nil) 298 ok <- true 299 if err != nil { 300 t.Errorf("Ppoll: unexpected error: %v", err) 301 return 302 } 303 if n != 0 { 304 t.Errorf("Ppoll: wrong number of events: got %v, expected %v", n, 0) 305 return 306 } 307 } 308 309 func TestTime(t *testing.T) { 310 var ut unix.Time_t 311 ut2, err := unix.Time(&ut) 312 if err != nil { 313 t.Fatalf("Time: %v", err) 314 } 315 if ut != ut2 { 316 t.Errorf("Time: return value %v should be equal to argument %v", ut2, ut) 317 } 318 319 var now time.Time 320 321 for i := 0; i < 10; i++ { 322 ut, err = unix.Time(nil) 323 if err != nil { 324 t.Fatalf("Time: %v", err) 325 } 326 327 now = time.Now() 328 diff := int64(ut) - now.Unix() 329 if -1 <= diff && diff <= 1 { 330 return 331 } 332 } 333 334 t.Errorf("Time: return value %v should be nearly equal to time.Now().Unix() %v±1", ut, now.Unix()) 335 } 336 337 func TestUtime(t *testing.T) { 338 defer chtmpdir(t)() 339 340 touch(t, "file1") 341 342 buf := &unix.Utimbuf{ 343 Modtime: 12345, 344 } 345 346 err := unix.Utime("file1", buf) 347 if err != nil { 348 t.Fatalf("Utime: %v", err) 349 } 350 351 fi, err := os.Stat("file1") 352 if err != nil { 353 t.Fatal(err) 354 } 355 356 if fi.ModTime().Unix() != 12345 { 357 t.Errorf("Utime: failed to change modtime: expected %v, got %v", 12345, fi.ModTime().Unix()) 358 } 359 } 360 361 func TestRlimitAs(t *testing.T) { 362 // disable GC during to avoid flaky test 363 defer debug.SetGCPercent(debug.SetGCPercent(-1)) 364 365 var rlim unix.Rlimit 366 err := unix.Getrlimit(unix.RLIMIT_AS, &rlim) 367 if err != nil { 368 t.Fatalf("Getrlimit: %v", err) 369 } 370 var zero unix.Rlimit 371 if zero == rlim { 372 t.Fatalf("Getrlimit: got zero value %#v", rlim) 373 } 374 set := rlim 375 set.Cur = uint64(unix.Getpagesize()) 376 err = unix.Setrlimit(unix.RLIMIT_AS, &set) 377 if err != nil { 378 t.Fatalf("Setrlimit: set failed: %#v %v", set, err) 379 } 380 381 // RLIMIT_AS was set to the page size, so mmap()'ing twice the page size 382 // should fail. See 'man 2 getrlimit'. 383 _, err = unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE) 384 if err == nil { 385 t.Fatal("Mmap: unexpectedly succeeded after setting RLIMIT_AS") 386 } 387 388 err = unix.Setrlimit(unix.RLIMIT_AS, &rlim) 389 if err != nil { 390 t.Fatalf("Setrlimit: restore failed: %#v %v", rlim, err) 391 } 392 393 b, err := unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE) 394 if err != nil { 395 t.Fatalf("Mmap: %v", err) 396 } 397 err = unix.Munmap(b) 398 if err != nil { 399 t.Fatalf("Munmap: %v", err) 400 } 401 } 402 403 func TestPselect(t *testing.T) { 404 for { 405 n, err := unix.Pselect(0, nil, nil, nil, &unix.Timespec{Sec: 0, Nsec: 0}, nil) 406 if err == unix.EINTR { 407 t.Logf("Pselect interrupted") 408 continue 409 } else if err != nil { 410 t.Fatalf("Pselect: %v", err) 411 } 412 if n != 0 { 413 t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n) 414 } 415 break 416 } 417 418 dur := 2500 * time.Microsecond 419 var took time.Duration 420 for { 421 // On some platforms (e.g. Linux), the passed-in timespec is 422 // updated by pselect(2). Make sure to reset to the full 423 // duration in case of an EINTR. 424 ts := unix.NsecToTimespec(int64(dur)) 425 start := time.Now() 426 n, err := unix.Pselect(0, nil, nil, nil, &ts, nil) 427 took = time.Since(start) 428 if err == unix.EINTR { 429 t.Logf("Pselect interrupted after %v", took) 430 continue 431 } else if err != nil { 432 t.Fatalf("Pselect: %v", err) 433 } 434 if n != 0 { 435 t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n) 436 } 437 break 438 } 439 440 // On some builder the actual timeout might also be slightly less than the requested. 441 // Add an acceptable margin to avoid flaky tests. 442 if took < dur*2/3 { 443 t.Errorf("Pselect: got %v timeout, expected at least %v", took, dur) 444 } 445 } 446 447 func TestSchedSetaffinity(t *testing.T) { 448 var newMask unix.CPUSet 449 newMask.Zero() 450 if newMask.Count() != 0 { 451 t.Errorf("CpuZero: didn't zero CPU set: %v", newMask) 452 } 453 cpu := 1 454 newMask.Set(cpu) 455 if newMask.Count() != 1 || !newMask.IsSet(cpu) { 456 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask) 457 } 458 cpu = 5 459 newMask.Set(cpu) 460 if newMask.Count() != 2 || !newMask.IsSet(cpu) { 461 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask) 462 } 463 newMask.Clear(cpu) 464 if newMask.Count() != 1 || newMask.IsSet(cpu) { 465 t.Errorf("CpuClr: didn't clear CPU %d in set: %v", cpu, newMask) 466 } 467 468 runtime.LockOSThread() 469 defer runtime.UnlockOSThread() 470 471 var oldMask unix.CPUSet 472 err := unix.SchedGetaffinity(0, &oldMask) 473 if err != nil { 474 t.Fatalf("SchedGetaffinity: %v", err) 475 } 476 477 if runtime.NumCPU() < 2 { 478 t.Skip("skipping setaffinity tests on single CPU system") 479 } 480 if runtime.GOOS == "android" { 481 t.Skip("skipping setaffinity tests on android") 482 } 483 484 // On a system like ppc64x where some cores can be disabled using ppc64_cpu, 485 // setaffinity should only be called with enabled cores. The valid cores 486 // are found from the oldMask, but if none are found then the setaffinity 487 // tests are skipped. Issue #27875. 488 cpu = 1 489 if !oldMask.IsSet(cpu) { 490 newMask.Zero() 491 for i := 0; i < len(oldMask); i++ { 492 if oldMask.IsSet(i) { 493 newMask.Set(i) 494 break 495 } 496 } 497 if newMask.Count() == 0 { 498 t.Skip("skipping setaffinity tests if CPU not available") 499 } 500 } 501 502 err = unix.SchedSetaffinity(0, &newMask) 503 if err != nil { 504 t.Fatalf("SchedSetaffinity: %v", err) 505 } 506 507 var gotMask unix.CPUSet 508 err = unix.SchedGetaffinity(0, &gotMask) 509 if err != nil { 510 t.Fatalf("SchedGetaffinity: %v", err) 511 } 512 513 if gotMask != newMask { 514 t.Errorf("SchedSetaffinity: returned affinity mask does not match set affinity mask") 515 } 516 517 // Restore old mask so it doesn't affect successive tests 518 err = unix.SchedSetaffinity(0, &oldMask) 519 if err != nil { 520 t.Fatalf("SchedSetaffinity: %v", err) 521 } 522 } 523 524 func TestStatx(t *testing.T) { 525 var stx unix.Statx_t 526 err := unix.Statx(unix.AT_FDCWD, ".", 0, 0, &stx) 527 if err == unix.ENOSYS || err == unix.EPERM { 528 t.Skip("statx syscall is not available, skipping test") 529 } else if err != nil { 530 t.Fatalf("Statx: %v", err) 531 } 532 533 defer chtmpdir(t)() 534 touch(t, "file1") 535 536 var st unix.Stat_t 537 err = unix.Stat("file1", &st) 538 if err != nil { 539 t.Fatalf("Stat: %v", err) 540 } 541 542 flags := unix.AT_STATX_SYNC_AS_STAT 543 err = unix.Statx(unix.AT_FDCWD, "file1", flags, unix.STATX_ALL, &stx) 544 if err != nil { 545 t.Fatalf("Statx: %v", err) 546 } 547 548 if uint32(stx.Mode) != st.Mode { 549 t.Errorf("Statx: returned stat mode does not match Stat") 550 } 551 552 ctime := unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)} 553 mtime := unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)} 554 555 if stx.Ctime != ctime { 556 t.Errorf("Statx: returned stat ctime does not match Stat") 557 } 558 if stx.Mtime != mtime { 559 t.Errorf("Statx: returned stat mtime does not match Stat") 560 } 561 562 err = os.Symlink("file1", "symlink1") 563 if err != nil { 564 t.Fatal(err) 565 } 566 567 err = unix.Lstat("symlink1", &st) 568 if err != nil { 569 t.Fatalf("Lstat: %v", err) 570 } 571 572 err = unix.Statx(unix.AT_FDCWD, "symlink1", flags, unix.STATX_BASIC_STATS, &stx) 573 if err != nil { 574 t.Fatalf("Statx: %v", err) 575 } 576 577 // follow symlink, expect a regulat file 578 if stx.Mode&unix.S_IFREG == 0 { 579 t.Errorf("Statx: didn't follow symlink") 580 } 581 582 err = unix.Statx(unix.AT_FDCWD, "symlink1", flags|unix.AT_SYMLINK_NOFOLLOW, unix.STATX_ALL, &stx) 583 if err != nil { 584 t.Fatalf("Statx: %v", err) 585 } 586 587 // follow symlink, expect a symlink 588 if stx.Mode&unix.S_IFLNK == 0 { 589 t.Errorf("Statx: unexpectedly followed symlink") 590 } 591 if uint32(stx.Mode) != st.Mode { 592 t.Errorf("Statx: returned stat mode does not match Lstat") 593 } 594 595 ctime = unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)} 596 mtime = unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)} 597 598 if stx.Ctime != ctime { 599 t.Errorf("Statx: returned stat ctime does not match Lstat") 600 } 601 if stx.Mtime != mtime { 602 t.Errorf("Statx: returned stat mtime does not match Lstat") 603 } 604 } 605 606 // stringsFromByteSlice converts a sequence of attributes to a []string. 607 // On Linux, each entry is a NULL-terminated string. 608 func stringsFromByteSlice(buf []byte) []string { 609 var result []string 610 off := 0 611 for i, b := range buf { 612 if b == 0 { 613 result = append(result, string(buf[off:i])) 614 off = i + 1 615 } 616 } 617 return result 618 } 619 620 func TestFaccessat(t *testing.T) { 621 defer chtmpdir(t)() 622 touch(t, "file1") 623 624 err := unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 0) 625 if err != nil { 626 t.Errorf("Faccessat: unexpected error: %v", err) 627 } 628 629 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 2) 630 if err != unix.EINVAL { 631 t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err) 632 } 633 634 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_EACCESS) 635 if err != nil { 636 t.Errorf("Faccessat: unexpected error: %v", err) 637 } 638 639 err = os.Symlink("file1", "symlink1") 640 if err != nil { 641 t.Fatal(err) 642 } 643 644 err = unix.Faccessat(unix.AT_FDCWD, "symlink1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW) 645 if err != nil { 646 t.Errorf("Faccessat SYMLINK_NOFOLLOW: unexpected error %v", err) 647 } 648 649 // We can't really test AT_SYMLINK_NOFOLLOW, because there 650 // doesn't seem to be any way to change the mode of a symlink. 651 // We don't test AT_EACCESS because such tests are only 652 // meaningful if run as root. 653 654 err = unix.Fchmodat(unix.AT_FDCWD, "file1", 0, 0) 655 if err != nil { 656 t.Errorf("Fchmodat: unexpected error %v", err) 657 } 658 659 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.F_OK, unix.AT_SYMLINK_NOFOLLOW) 660 if err != nil { 661 t.Errorf("Faccessat: unexpected error: %v", err) 662 } 663 664 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW) 665 if err != unix.EACCES { 666 if unix.Getuid() != 0 { 667 t.Errorf("Faccessat: unexpected error: %v, want EACCES", err) 668 } 669 } 670 } 671 672 func TestSyncFileRange(t *testing.T) { 673 file, err := ioutil.TempFile("", "TestSyncFileRange") 674 if err != nil { 675 t.Fatal(err) 676 } 677 defer os.Remove(file.Name()) 678 defer file.Close() 679 680 err = unix.SyncFileRange(int(file.Fd()), 0, 0, 0) 681 if err == unix.ENOSYS || err == unix.EPERM { 682 t.Skip("sync_file_range syscall is not available, skipping test") 683 } else if err != nil { 684 t.Fatalf("SyncFileRange: %v", err) 685 } 686 687 // invalid flags 688 flags := 0xf00 689 err = unix.SyncFileRange(int(file.Fd()), 0, 0, flags) 690 if err != unix.EINVAL { 691 t.Fatalf("SyncFileRange: unexpected error: %v, want EINVAL", err) 692 } 693 } 694 695 func TestClockNanosleep(t *testing.T) { 696 delay := 50 * time.Millisecond 697 698 // Relative timespec. 699 start := time.Now() 700 rel := unix.NsecToTimespec(delay.Nanoseconds()) 701 remain := unix.Timespec{} 702 for { 703 err := unix.ClockNanosleep(unix.CLOCK_MONOTONIC, 0, &rel, &remain) 704 if err == unix.ENOSYS || err == unix.EPERM { 705 t.Skip("clock_nanosleep syscall is not available, skipping test") 706 } else if err == unix.EINTR { 707 t.Logf("ClockNanosleep interrupted after %v", time.Since(start)) 708 rel = remain 709 continue 710 } else if err != nil { 711 t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) = %v", &rel, err) 712 } else if slept := time.Since(start); slept < delay { 713 t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) slept only %v", &rel, slept) 714 } 715 break 716 } 717 718 // Absolute timespec. 719 for { 720 start = time.Now() 721 until := start.Add(delay) 722 abs := unix.NsecToTimespec(until.UnixNano()) 723 err := unix.ClockNanosleep(unix.CLOCK_REALTIME, unix.TIMER_ABSTIME, &abs, nil) 724 if err == unix.EINTR { 725 t.Logf("ClockNanosleep interrupted after %v", time.Since(start)) 726 continue 727 } else if err != nil { 728 t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) = %v", &abs, until, err) 729 } else { 730 // We asked for CLOCK_REALTIME, but we have no way to know whether it 731 // jumped backward after ClockNanosleep returned. Compare both ways, 732 // and only fail if both the monotonic and wall clocks agree that 733 // the elapsed sleep was too short. 734 // 735 // This can still theoretically fail spuriously: if the clock jumps 736 // forward during ClockNanosleep and then backward again before we can 737 // call time.Now, then we could end up with a time that is too short on 738 // both the monotonic scale (because of the forward jump) and the 739 // real-time scale (because of the backward jump. However, it seems 740 // unlikely that two such contrary jumps will ever occur in the time it 741 // takes to execute this test. 742 if now := time.Now(); now.Before(until) && now.Round(0).Before(until) { 743 t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) slept only until %v", &abs, until, now) 744 } 745 } 746 break 747 } 748 749 // Invalid clock. clock_nanosleep(2) says EINVAL, but it’s actually EOPNOTSUPP. 750 err := unix.ClockNanosleep(unix.CLOCK_THREAD_CPUTIME_ID, 0, &rel, nil) 751 if err != unix.EINVAL && err != unix.EOPNOTSUPP { 752 t.Errorf("ClockNanosleep(CLOCK_THREAD_CPUTIME_ID, 0, %#v, nil) = %v, want EINVAL or EOPNOTSUPP", &rel, err) 753 } 754 } 755 756 func TestOpenByHandleAt(t *testing.T) { 757 skipIfNotSupported := func(t *testing.T, name string, err error) { 758 if err == unix.EPERM { 759 t.Skipf("skipping %s test without CAP_DAC_READ_SEARCH", name) 760 } 761 if err == unix.ENOSYS { 762 t.Skipf("%s system call not available", name) 763 } 764 if err == unix.EOPNOTSUPP { 765 t.Skipf("%s not supported on this filesystem", name) 766 } 767 } 768 769 h, mountID, err := unix.NameToHandleAt(unix.AT_FDCWD, "syscall_linux_test.go", 0) 770 if err != nil { 771 skipIfNotSupported(t, "name_to_handle_at", err) 772 t.Fatalf("NameToHandleAt: %v", err) 773 } 774 t.Logf("mountID: %v, handle: size=%d, type=%d, bytes=%q", mountID, 775 h.Size(), h.Type(), h.Bytes()) 776 mount, err := openMountByID(mountID) 777 if err != nil { 778 t.Fatalf("openMountByID: %v", err) 779 } 780 defer mount.Close() 781 782 for _, clone := range []bool{false, true} { 783 t.Run("clone="+strconv.FormatBool(clone), func(t *testing.T) { 784 if clone { 785 h = unix.NewFileHandle(h.Type(), h.Bytes()) 786 } 787 fd, err := unix.OpenByHandleAt(int(mount.Fd()), h, unix.O_RDONLY) 788 skipIfNotSupported(t, "open_by_handle_at", err) 789 if err != nil { 790 t.Fatalf("OpenByHandleAt: %v", err) 791 } 792 t.Logf("opened fd %v", fd) 793 f := os.NewFile(uintptr(fd), "") 794 defer f.Close() 795 796 slurp, err := ioutil.ReadAll(f) 797 if err != nil { 798 t.Fatal(err) 799 } 800 const substr = "Some substring for a test." 801 if !strings.Contains(string(slurp), substr) { 802 t.Errorf("didn't find substring %q in opened file; read %d bytes", substr, len(slurp)) 803 } 804 }) 805 } 806 } 807 808 func openMountByID(mountID int) (f *os.File, err error) { 809 mi, err := os.Open("/proc/self/mountinfo") 810 if err != nil { 811 return nil, err 812 } 813 defer mi.Close() 814 bs := bufio.NewScanner(mi) 815 wantPrefix := []byte(fmt.Sprintf("%v ", mountID)) 816 for bs.Scan() { 817 if !bytes.HasPrefix(bs.Bytes(), wantPrefix) { 818 continue 819 } 820 fields := strings.Fields(bs.Text()) 821 dev := fields[4] 822 return os.Open(dev) 823 } 824 if err := bs.Err(); err != nil { 825 return nil, err 826 } 827 return nil, errors.New("mountID not found") 828 } 829 830 func TestEpoll(t *testing.T) { 831 efd, err := unix.EpollCreate1(unix.EPOLL_CLOEXEC) 832 if err != nil { 833 t.Fatalf("EpollCreate1: %v", err) 834 } 835 defer unix.Close(efd) 836 837 r, w, err := os.Pipe() 838 if err != nil { 839 t.Fatal(err) 840 } 841 defer r.Close() 842 defer w.Close() 843 844 fd := int(r.Fd()) 845 ev := unix.EpollEvent{Events: unix.EPOLLIN, Fd: int32(fd)} 846 847 err = unix.EpollCtl(efd, unix.EPOLL_CTL_ADD, fd, &ev) 848 if err != nil { 849 t.Fatalf("EpollCtl: %v", err) 850 } 851 852 if _, err := w.Write([]byte("HELLO GOPHER")); err != nil { 853 t.Fatal(err) 854 } 855 856 events := make([]unix.EpollEvent, 128) 857 n, err := unix.EpollWait(efd, events, 1) 858 if err != nil { 859 t.Fatalf("EpollWait: %v", err) 860 } 861 862 if n != 1 { 863 t.Errorf("EpollWait: wrong number of events: got %v, expected 1", n) 864 } 865 866 got := int(events[0].Fd) 867 if got != fd { 868 t.Errorf("EpollWait: wrong Fd in event: got %v, expected %v", got, fd) 869 } 870 } 871 872 func TestPrctlRetInt(t *testing.T) { 873 skipc := make(chan bool, 1) 874 skip := func() { 875 skipc <- true 876 runtime.Goexit() 877 } 878 879 go func() { 880 // This test uses prctl to modify the calling thread, so run it on its own 881 // throwaway thread and do not unlock it when the goroutine exits. 882 runtime.LockOSThread() 883 defer close(skipc) 884 885 err := unix.Prctl(unix.PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) 886 if err != nil { 887 t.Logf("Prctl: %v, skipping test", err) 888 skip() 889 } 890 891 v, err := unix.PrctlRetInt(unix.PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0) 892 if err != nil { 893 t.Errorf("failed to perform prctl: %v", err) 894 } 895 if v != 1 { 896 t.Errorf("unexpected return from prctl; got %v, expected %v", v, 1) 897 } 898 }() 899 900 if <-skipc { 901 t.SkipNow() 902 } 903 } 904 905 func TestTimerfd(t *testing.T) { 906 var now unix.Timespec 907 if err := unix.ClockGettime(unix.CLOCK_REALTIME, &now); err != nil { 908 t.Fatalf("ClockGettime: %v", err) 909 } 910 911 tfd, err := unix.TimerfdCreate(unix.CLOCK_REALTIME, 0) 912 if err == unix.ENOSYS { 913 t.Skip("timerfd_create system call not implemented") 914 } else if err != nil { 915 t.Fatalf("TimerfdCreate: %v", err) 916 } 917 defer unix.Close(tfd) 918 919 var timeSpec unix.ItimerSpec 920 if err := unix.TimerfdGettime(tfd, &timeSpec); err != nil { 921 t.Fatalf("TimerfdGettime: %v", err) 922 } 923 924 if timeSpec.Value.Nsec != 0 || timeSpec.Value.Sec != 0 { 925 t.Fatalf("TimerfdGettime: timer is already set, but shouldn't be") 926 } 927 928 timeSpec = unix.ItimerSpec{ 929 Interval: unix.NsecToTimespec(int64(time.Millisecond)), 930 Value: now, 931 } 932 933 if err := unix.TimerfdSettime(tfd, unix.TFD_TIMER_ABSTIME, &timeSpec, nil); err != nil { 934 t.Fatalf("TimerfdSettime: %v", err) 935 } 936 937 const totalTicks = 10 938 const bufferLength = 8 939 940 buffer := make([]byte, bufferLength) 941 942 var count uint64 = 0 943 for count < totalTicks { 944 n, err := unix.Read(tfd, buffer) 945 if err != nil { 946 t.Fatalf("Timerfd: %v", err) 947 } else if n != bufferLength { 948 t.Fatalf("Timerfd: got %d bytes from timerfd, expected %d bytes", n, bufferLength) 949 } 950 951 count += *(*uint64)(unsafe.Pointer(&buffer)) 952 } 953 } 954 955 func TestOpenat2(t *testing.T) { 956 how := &unix.OpenHow{ 957 Flags: unix.O_RDONLY, 958 } 959 fd, err := unix.Openat2(unix.AT_FDCWD, ".", how) 960 if err != nil { 961 if err == unix.ENOSYS || err == unix.EPERM { 962 t.Skipf("openat2: %v (old kernel? need Linux >= 5.6)", err) 963 } 964 t.Fatalf("openat2: %v", err) 965 } 966 if err := unix.Close(fd); err != nil { 967 t.Fatalf("close: %v", err) 968 } 969 970 // prepare 971 tempDir, err := ioutil.TempDir("", t.Name()) 972 if err != nil { 973 t.Fatal(err) 974 } 975 defer os.RemoveAll(tempDir) 976 977 subdir := filepath.Join(tempDir, "dir") 978 if err := os.Mkdir(subdir, 0755); err != nil { 979 t.Fatal(err) 980 } 981 symlink := filepath.Join(subdir, "symlink") 982 if err := os.Symlink("../", symlink); err != nil { 983 t.Fatal(err) 984 } 985 986 dirfd, err := unix.Open(subdir, unix.O_RDONLY, 0) 987 if err != nil { 988 t.Fatalf("open(%q): %v", subdir, err) 989 } 990 defer unix.Close(dirfd) 991 992 // openat2 with no extra flags -- should succeed 993 fd, err = unix.Openat2(dirfd, "symlink", how) 994 if err != nil { 995 t.Errorf("Openat2 should succeed, got %v", err) 996 } 997 if err := unix.Close(fd); err != nil { 998 t.Fatalf("close: %v", err) 999 } 1000 1001 // open with RESOLVE_BENEATH, should result in EXDEV 1002 how.Resolve = unix.RESOLVE_BENEATH 1003 fd, err = unix.Openat2(dirfd, "symlink", how) 1004 if err == nil { 1005 if err := unix.Close(fd); err != nil { 1006 t.Fatalf("close: %v", err) 1007 } 1008 } 1009 if err != unix.EXDEV { 1010 t.Errorf("Openat2 should fail with EXDEV, got %v", err) 1011 } 1012 } 1013 1014 func TestIoctlFileDedupeRange(t *testing.T) { 1015 f1, err := ioutil.TempFile("", t.Name()) 1016 if err != nil { 1017 t.Fatal(err) 1018 } 1019 defer f1.Close() 1020 defer os.Remove(f1.Name()) 1021 1022 // Test deduplication with two blocks of zeros 1023 data := make([]byte, 4096) 1024 1025 for i := 0; i < 2; i += 1 { 1026 _, err = f1.Write(data) 1027 if err != nil { 1028 t.Fatal(err) 1029 } 1030 } 1031 1032 f2, err := ioutil.TempFile("", t.Name()) 1033 if err != nil { 1034 t.Fatal(err) 1035 } 1036 defer f2.Close() 1037 defer os.Remove(f2.Name()) 1038 1039 for i := 0; i < 2; i += 1 { 1040 // Make the 2nd block different 1041 if i == 1 { 1042 data[1] = 1 1043 } 1044 1045 _, err = f2.Write(data) 1046 if err != nil { 1047 t.Fatal(err) 1048 } 1049 } 1050 1051 dedupe := unix.FileDedupeRange{ 1052 Src_offset: uint64(0), 1053 Src_length: uint64(4096), 1054 Info: []unix.FileDedupeRangeInfo{ 1055 unix.FileDedupeRangeInfo{ 1056 Dest_fd: int64(f2.Fd()), 1057 Dest_offset: uint64(0), 1058 }, 1059 unix.FileDedupeRangeInfo{ 1060 Dest_fd: int64(f2.Fd()), 1061 Dest_offset: uint64(4096), 1062 }, 1063 }} 1064 1065 err = unix.IoctlFileDedupeRange(int(f1.Fd()), &dedupe) 1066 if err == unix.EOPNOTSUPP || err == unix.EINVAL || err == unix.ENOTTY { 1067 t.Skip("deduplication not supported on this filesystem") 1068 } else if err != nil { 1069 t.Fatal(err) 1070 } 1071 1072 // The first Info should be equal 1073 if dedupe.Info[0].Status < 0 { 1074 errno := unix.Errno(-dedupe.Info[0].Status) 1075 if errno == unix.EINVAL { 1076 t.Skip("deduplication not supported on this filesystem") 1077 } 1078 t.Errorf("Unexpected error in FileDedupeRange: %s", unix.ErrnoName(errno)) 1079 } else if dedupe.Info[0].Status == unix.FILE_DEDUPE_RANGE_DIFFERS { 1080 t.Errorf("Unexpected different bytes in FileDedupeRange") 1081 } 1082 if dedupe.Info[0].Bytes_deduped != 4096 { 1083 t.Errorf("Unexpected amount of bytes deduped %v != %v", 1084 dedupe.Info[0].Bytes_deduped, 4096) 1085 } 1086 1087 // The second Info should be different 1088 if dedupe.Info[1].Status < 0 { 1089 errno := unix.Errno(-dedupe.Info[1].Status) 1090 if errno == unix.EINVAL { 1091 t.Skip("deduplication not supported on this filesystem") 1092 } 1093 t.Errorf("Unexpected error in FileDedupeRange: %s", unix.ErrnoName(errno)) 1094 } else if dedupe.Info[1].Status == unix.FILE_DEDUPE_RANGE_SAME { 1095 t.Errorf("Unexpected equal bytes in FileDedupeRange") 1096 } 1097 if dedupe.Info[1].Bytes_deduped != 0 { 1098 t.Errorf("Unexpected amount of bytes deduped %v != %v", 1099 dedupe.Info[1].Bytes_deduped, 0) 1100 } 1101 }