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// +build linux 6 7package unix_test 8 9import ( 10 "bufio" 11 "bytes" 12 "errors" 13 "fmt" 14 "io/ioutil" 15 "os" 16 "path/filepath" 17 "runtime" 18 "runtime/debug" 19 "strconv" 20 "strings" 21 "testing" 22 "time" 23 "unsafe" 24 25 "golang.org/x/sys/unix" 26) 27 28func TestIoctlGetInt(t *testing.T) { 29 f, err := os.Open("/dev/random") 30 if err != nil { 31 t.Fatalf("failed to open device: %v", err) 32 } 33 defer f.Close() 34 35 v, err := unix.IoctlGetInt(int(f.Fd()), unix.RNDGETENTCNT) 36 if err != nil { 37 t.Fatalf("failed to perform ioctl: %v", err) 38 } 39 40 t.Logf("%d bits of entropy available", v) 41} 42 43func TestIoctlRetInt(t *testing.T) { 44 f, err := os.Open("/proc/self/ns/mnt") 45 if err != nil { 46 t.Skipf("skipping test, %v", err) 47 } 48 defer f.Close() 49 50 v, err := unix.IoctlRetInt(int(f.Fd()), unix.NS_GET_NSTYPE) 51 if err != nil { 52 if err == unix.ENOTTY { 53 t.Skipf("old kernel? (need Linux >= 4.11)") 54 } 55 t.Fatalf("failed to perform ioctl: %v", err) 56 } 57 if v != unix.CLONE_NEWNS { 58 t.Fatalf("unexpected return from ioctl; expected %v, got %v", v, unix.CLONE_NEWNS) 59 } 60} 61 62func TestIoctlGetRTCTime(t *testing.T) { 63 f, err := os.Open("/dev/rtc0") 64 if err != nil { 65 t.Skipf("skipping test, %v", err) 66 } 67 defer f.Close() 68 69 v, err := unix.IoctlGetRTCTime(int(f.Fd())) 70 if err != nil { 71 t.Fatalf("failed to perform ioctl: %v", err) 72 } 73 74 t.Logf("RTC time: %04d-%02d-%02d %02d:%02d:%02d", v.Year+1900, v.Mon+1, v.Mday, v.Hour, v.Min, v.Sec) 75} 76 77func TestIoctlGetRTCWkAlrm(t *testing.T) { 78 f, err := os.Open("/dev/rtc0") 79 if err != nil { 80 t.Skipf("skipping test, %v", err) 81 } 82 defer f.Close() 83 84 v, err := unix.IoctlGetRTCWkAlrm(int(f.Fd())) 85 if err != nil { 86 t.Fatalf("failed to perform ioctl: %v", err) 87 } 88 89 t.Logf("RTC wake alarm enabled '%d'; time: %04d-%02d-%02d %02d:%02d:%02d", 90 v.Enabled, v.Time.Year+1900, v.Time.Mon+1, v.Time.Mday, v.Time.Hour, v.Time.Min, v.Time.Sec) 91} 92 93func TestPpoll(t *testing.T) { 94 if runtime.GOOS == "android" { 95 t.Skip("mkfifo syscall is not available on android, skipping test") 96 } 97 98 defer chtmpdir(t)() 99 f, cleanup := mktmpfifo(t) 100 defer cleanup() 101 102 const timeout = 100 * time.Millisecond 103 104 ok := make(chan bool, 1) 105 go func() { 106 select { 107 case <-time.After(10 * timeout): 108 t.Errorf("Ppoll: failed to timeout after %d", 10*timeout) 109 case <-ok: 110 } 111 }() 112 113 fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}} 114 timeoutTs := unix.NsecToTimespec(int64(timeout)) 115 n, err := unix.Ppoll(fds, &timeoutTs, nil) 116 ok <- true 117 if err != nil { 118 t.Errorf("Ppoll: unexpected error: %v", err) 119 return 120 } 121 if n != 0 { 122 t.Errorf("Ppoll: wrong number of events: got %v, expected %v", n, 0) 123 return 124 } 125} 126 127func TestTime(t *testing.T) { 128 var ut unix.Time_t 129 ut2, err := unix.Time(&ut) 130 if err != nil { 131 t.Fatalf("Time: %v", err) 132 } 133 if ut != ut2 { 134 t.Errorf("Time: return value %v should be equal to argument %v", ut2, ut) 135 } 136 137 var now time.Time 138 139 for i := 0; i < 10; i++ { 140 ut, err = unix.Time(nil) 141 if err != nil { 142 t.Fatalf("Time: %v", err) 143 } 144 145 now = time.Now() 146 diff := int64(ut) - now.Unix() 147 if -1 <= diff && diff <= 1 { 148 return 149 } 150 } 151 152 t.Errorf("Time: return value %v should be nearly equal to time.Now().Unix() %v±1", ut, now.Unix()) 153} 154 155func TestUtime(t *testing.T) { 156 defer chtmpdir(t)() 157 158 touch(t, "file1") 159 160 buf := &unix.Utimbuf{ 161 Modtime: 12345, 162 } 163 164 err := unix.Utime("file1", buf) 165 if err != nil { 166 t.Fatalf("Utime: %v", err) 167 } 168 169 fi, err := os.Stat("file1") 170 if err != nil { 171 t.Fatal(err) 172 } 173 174 if fi.ModTime().Unix() != 12345 { 175 t.Errorf("Utime: failed to change modtime: expected %v, got %v", 12345, fi.ModTime().Unix()) 176 } 177} 178 179func TestRlimitAs(t *testing.T) { 180 // disable GC during to avoid flaky test 181 defer debug.SetGCPercent(debug.SetGCPercent(-1)) 182 183 var rlim unix.Rlimit 184 err := unix.Getrlimit(unix.RLIMIT_AS, &rlim) 185 if err != nil { 186 t.Fatalf("Getrlimit: %v", err) 187 } 188 var zero unix.Rlimit 189 if zero == rlim { 190 t.Fatalf("Getrlimit: got zero value %#v", rlim) 191 } 192 set := rlim 193 set.Cur = uint64(unix.Getpagesize()) 194 err = unix.Setrlimit(unix.RLIMIT_AS, &set) 195 if err != nil { 196 t.Fatalf("Setrlimit: set failed: %#v %v", set, err) 197 } 198 199 // RLIMIT_AS was set to the page size, so mmap()'ing twice the page size 200 // should fail. See 'man 2 getrlimit'. 201 _, err = unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE) 202 if err == nil { 203 t.Fatal("Mmap: unexpectedly succeeded after setting RLIMIT_AS") 204 } 205 206 err = unix.Setrlimit(unix.RLIMIT_AS, &rlim) 207 if err != nil { 208 t.Fatalf("Setrlimit: restore failed: %#v %v", rlim, err) 209 } 210 211 b, err := unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE) 212 if err != nil { 213 t.Fatalf("Mmap: %v", err) 214 } 215 err = unix.Munmap(b) 216 if err != nil { 217 t.Fatalf("Munmap: %v", err) 218 } 219} 220 221func TestPselect(t *testing.T) { 222 for { 223 n, err := unix.Pselect(0, nil, nil, nil, &unix.Timespec{Sec: 0, Nsec: 0}, nil) 224 if err == unix.EINTR { 225 t.Logf("Pselect interrupted") 226 continue 227 } else if err != nil { 228 t.Fatalf("Pselect: %v", err) 229 } 230 if n != 0 { 231 t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n) 232 } 233 break 234 } 235 236 dur := 2500 * time.Microsecond 237 ts := unix.NsecToTimespec(int64(dur)) 238 var took time.Duration 239 for { 240 start := time.Now() 241 n, err := unix.Pselect(0, nil, nil, nil, &ts, nil) 242 took = time.Since(start) 243 if err == unix.EINTR { 244 t.Logf("Pselect interrupted after %v", took) 245 continue 246 } else if err != nil { 247 t.Fatalf("Pselect: %v", err) 248 } 249 if n != 0 { 250 t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n) 251 } 252 break 253 } 254 255 if took < dur { 256 t.Errorf("Pselect: timeout should have been at least %v, got %v", dur, took) 257 } 258} 259 260func TestSchedSetaffinity(t *testing.T) { 261 var newMask unix.CPUSet 262 newMask.Zero() 263 if newMask.Count() != 0 { 264 t.Errorf("CpuZero: didn't zero CPU set: %v", newMask) 265 } 266 cpu := 1 267 newMask.Set(cpu) 268 if newMask.Count() != 1 || !newMask.IsSet(cpu) { 269 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask) 270 } 271 cpu = 5 272 newMask.Set(cpu) 273 if newMask.Count() != 2 || !newMask.IsSet(cpu) { 274 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask) 275 } 276 newMask.Clear(cpu) 277 if newMask.Count() != 1 || newMask.IsSet(cpu) { 278 t.Errorf("CpuClr: didn't clear CPU %d in set: %v", cpu, newMask) 279 } 280 281 runtime.LockOSThread() 282 defer runtime.UnlockOSThread() 283 284 var oldMask unix.CPUSet 285 err := unix.SchedGetaffinity(0, &oldMask) 286 if err != nil { 287 t.Fatalf("SchedGetaffinity: %v", err) 288 } 289 290 if runtime.NumCPU() < 2 { 291 t.Skip("skipping setaffinity tests on single CPU system") 292 } 293 if runtime.GOOS == "android" { 294 t.Skip("skipping setaffinity tests on android") 295 } 296 297 // On a system like ppc64x where some cores can be disabled using ppc64_cpu, 298 // setaffinity should only be called with enabled cores. The valid cores 299 // are found from the oldMask, but if none are found then the setaffinity 300 // tests are skipped. Issue #27875. 301 cpu = 1 302 if !oldMask.IsSet(cpu) { 303 newMask.Zero() 304 for i := 0; i < len(oldMask); i++ { 305 if oldMask.IsSet(i) { 306 newMask.Set(i) 307 break 308 } 309 } 310 if newMask.Count() == 0 { 311 t.Skip("skipping setaffinity tests if CPU not available") 312 } 313 } 314 315 err = unix.SchedSetaffinity(0, &newMask) 316 if err != nil { 317 t.Fatalf("SchedSetaffinity: %v", err) 318 } 319 320 var gotMask unix.CPUSet 321 err = unix.SchedGetaffinity(0, &gotMask) 322 if err != nil { 323 t.Fatalf("SchedGetaffinity: %v", err) 324 } 325 326 if gotMask != newMask { 327 t.Errorf("SchedSetaffinity: returned affinity mask does not match set affinity mask") 328 } 329 330 // Restore old mask so it doesn't affect successive tests 331 err = unix.SchedSetaffinity(0, &oldMask) 332 if err != nil { 333 t.Fatalf("SchedSetaffinity: %v", err) 334 } 335} 336 337func TestStatx(t *testing.T) { 338 var stx unix.Statx_t 339 err := unix.Statx(unix.AT_FDCWD, ".", 0, 0, &stx) 340 if err == unix.ENOSYS || err == unix.EPERM { 341 t.Skip("statx syscall is not available, skipping test") 342 } else if err != nil { 343 t.Fatalf("Statx: %v", err) 344 } 345 346 defer chtmpdir(t)() 347 touch(t, "file1") 348 349 var st unix.Stat_t 350 err = unix.Stat("file1", &st) 351 if err != nil { 352 t.Fatalf("Stat: %v", err) 353 } 354 355 flags := unix.AT_STATX_SYNC_AS_STAT 356 err = unix.Statx(unix.AT_FDCWD, "file1", flags, unix.STATX_ALL, &stx) 357 if err != nil { 358 t.Fatalf("Statx: %v", err) 359 } 360 361 if uint32(stx.Mode) != st.Mode { 362 t.Errorf("Statx: returned stat mode does not match Stat") 363 } 364 365 ctime := unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)} 366 mtime := unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)} 367 368 if stx.Ctime != ctime { 369 t.Errorf("Statx: returned stat ctime does not match Stat") 370 } 371 if stx.Mtime != mtime { 372 t.Errorf("Statx: returned stat mtime does not match Stat") 373 } 374 375 err = os.Symlink("file1", "symlink1") 376 if err != nil { 377 t.Fatal(err) 378 } 379 380 err = unix.Lstat("symlink1", &st) 381 if err != nil { 382 t.Fatalf("Lstat: %v", err) 383 } 384 385 err = unix.Statx(unix.AT_FDCWD, "symlink1", flags, unix.STATX_BASIC_STATS, &stx) 386 if err != nil { 387 t.Fatalf("Statx: %v", err) 388 } 389 390 // follow symlink, expect a regulat file 391 if stx.Mode&unix.S_IFREG == 0 { 392 t.Errorf("Statx: didn't follow symlink") 393 } 394 395 err = unix.Statx(unix.AT_FDCWD, "symlink1", flags|unix.AT_SYMLINK_NOFOLLOW, unix.STATX_ALL, &stx) 396 if err != nil { 397 t.Fatalf("Statx: %v", err) 398 } 399 400 // follow symlink, expect a symlink 401 if stx.Mode&unix.S_IFLNK == 0 { 402 t.Errorf("Statx: unexpectedly followed symlink") 403 } 404 if uint32(stx.Mode) != st.Mode { 405 t.Errorf("Statx: returned stat mode does not match Lstat") 406 } 407 408 ctime = unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)} 409 mtime = unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)} 410 411 if stx.Ctime != ctime { 412 t.Errorf("Statx: returned stat ctime does not match Lstat") 413 } 414 if stx.Mtime != mtime { 415 t.Errorf("Statx: returned stat mtime does not match Lstat") 416 } 417} 418 419// stringsFromByteSlice converts a sequence of attributes to a []string. 420// On Linux, each entry is a NULL-terminated string. 421func stringsFromByteSlice(buf []byte) []string { 422 var result []string 423 off := 0 424 for i, b := range buf { 425 if b == 0 { 426 result = append(result, string(buf[off:i])) 427 off = i + 1 428 } 429 } 430 return result 431} 432 433func TestFaccessat(t *testing.T) { 434 defer chtmpdir(t)() 435 touch(t, "file1") 436 437 err := unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 0) 438 if err != nil { 439 t.Errorf("Faccessat: unexpected error: %v", err) 440 } 441 442 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 2) 443 if err != unix.EINVAL { 444 t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err) 445 } 446 447 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_EACCESS) 448 if err != nil { 449 t.Errorf("Faccessat: unexpected error: %v", err) 450 } 451 452 err = os.Symlink("file1", "symlink1") 453 if err != nil { 454 t.Fatal(err) 455 } 456 457 err = unix.Faccessat(unix.AT_FDCWD, "symlink1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW) 458 if err != nil { 459 t.Errorf("Faccessat SYMLINK_NOFOLLOW: unexpected error %v", err) 460 } 461 462 // We can't really test AT_SYMLINK_NOFOLLOW, because there 463 // doesn't seem to be any way to change the mode of a symlink. 464 // We don't test AT_EACCESS because such tests are only 465 // meaningful if run as root. 466 467 err = unix.Fchmodat(unix.AT_FDCWD, "file1", 0, 0) 468 if err != nil { 469 t.Errorf("Fchmodat: unexpected error %v", err) 470 } 471 472 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.F_OK, unix.AT_SYMLINK_NOFOLLOW) 473 if err != nil { 474 t.Errorf("Faccessat: unexpected error: %v", err) 475 } 476 477 err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW) 478 if err != unix.EACCES { 479 if unix.Getuid() != 0 { 480 t.Errorf("Faccessat: unexpected error: %v, want EACCES", err) 481 } 482 } 483} 484 485func TestSyncFileRange(t *testing.T) { 486 file, err := ioutil.TempFile("", "TestSyncFileRange") 487 if err != nil { 488 t.Fatal(err) 489 } 490 defer os.Remove(file.Name()) 491 defer file.Close() 492 493 err = unix.SyncFileRange(int(file.Fd()), 0, 0, 0) 494 if err == unix.ENOSYS || err == unix.EPERM { 495 t.Skip("sync_file_range syscall is not available, skipping test") 496 } else if err != nil { 497 t.Fatalf("SyncFileRange: %v", err) 498 } 499 500 // invalid flags 501 flags := 0xf00 502 err = unix.SyncFileRange(int(file.Fd()), 0, 0, flags) 503 if err != unix.EINVAL { 504 t.Fatalf("SyncFileRange: unexpected error: %v, want EINVAL", err) 505 } 506} 507 508func TestClockNanosleep(t *testing.T) { 509 delay := 50 * time.Millisecond 510 511 // Relative timespec. 512 start := time.Now() 513 rel := unix.NsecToTimespec(delay.Nanoseconds()) 514 remain := unix.Timespec{} 515 for { 516 err := unix.ClockNanosleep(unix.CLOCK_MONOTONIC, 0, &rel, &remain) 517 if err == unix.ENOSYS || err == unix.EPERM { 518 t.Skip("clock_nanosleep syscall is not available, skipping test") 519 } else if err == unix.EINTR { 520 t.Logf("ClockNanosleep interrupted after %v", time.Since(start)) 521 rel = remain 522 continue 523 } else if err != nil { 524 t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) = %v", &rel, err) 525 } else if slept := time.Since(start); slept < delay { 526 t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) slept only %v", &rel, slept) 527 } 528 break 529 } 530 531 // Absolute timespec. 532 for { 533 start = time.Now() 534 until := start.Add(delay) 535 abs := unix.NsecToTimespec(until.UnixNano()) 536 err := unix.ClockNanosleep(unix.CLOCK_REALTIME, unix.TIMER_ABSTIME, &abs, nil) 537 if err == unix.EINTR { 538 t.Logf("ClockNanosleep interrupted after %v", time.Since(start)) 539 continue 540 } else if err != nil { 541 t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) = %v", &abs, until, err) 542 } else if slept := time.Since(start); slept < delay { 543 t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) slept only %v", &abs, until, slept) 544 } 545 break 546 } 547 548 // Invalid clock. clock_nanosleep(2) says EINVAL, but it’s actually EOPNOTSUPP. 549 err := unix.ClockNanosleep(unix.CLOCK_THREAD_CPUTIME_ID, 0, &rel, nil) 550 if err != unix.EINVAL && err != unix.EOPNOTSUPP { 551 t.Errorf("ClockNanosleep(CLOCK_THREAD_CPUTIME_ID, 0, %#v, nil) = %v, want EINVAL or EOPNOTSUPP", &rel, err) 552 } 553} 554 555func TestOpenByHandleAt(t *testing.T) { 556 skipIfNotSupported := func(t *testing.T, name string, err error) { 557 if err == unix.EPERM { 558 t.Skipf("skipping %s test without CAP_DAC_READ_SEARCH", name) 559 } 560 if err == unix.ENOSYS { 561 t.Skipf("%s system call not available", name) 562 } 563 if err == unix.EOPNOTSUPP { 564 t.Skipf("%s not supported on this filesystem", name) 565 } 566 } 567 568 h, mountID, err := unix.NameToHandleAt(unix.AT_FDCWD, "syscall_linux_test.go", 0) 569 if err != nil { 570 skipIfNotSupported(t, "name_to_handle_at", err) 571 t.Fatalf("NameToHandleAt: %v", err) 572 } 573 t.Logf("mountID: %v, handle: size=%d, type=%d, bytes=%q", mountID, 574 h.Size(), h.Type(), h.Bytes()) 575 mount, err := openMountByID(mountID) 576 if err != nil { 577 t.Fatalf("openMountByID: %v", err) 578 } 579 defer mount.Close() 580 581 for _, clone := range []bool{false, true} { 582 t.Run("clone="+strconv.FormatBool(clone), func(t *testing.T) { 583 if clone { 584 h = unix.NewFileHandle(h.Type(), h.Bytes()) 585 } 586 fd, err := unix.OpenByHandleAt(int(mount.Fd()), h, unix.O_RDONLY) 587 skipIfNotSupported(t, "open_by_handle_at", err) 588 if err != nil { 589 t.Fatalf("OpenByHandleAt: %v", err) 590 } 591 defer unix.Close(fd) 592 593 t.Logf("opened fd %v", fd) 594 f := os.NewFile(uintptr(fd), "") 595 slurp, err := ioutil.ReadAll(f) 596 if err != nil { 597 t.Fatal(err) 598 } 599 const substr = "Some substring for a test." 600 if !strings.Contains(string(slurp), substr) { 601 t.Errorf("didn't find substring %q in opened file; read %d bytes", substr, len(slurp)) 602 } 603 }) 604 } 605} 606 607func openMountByID(mountID int) (f *os.File, err error) { 608 mi, err := os.Open("/proc/self/mountinfo") 609 if err != nil { 610 return nil, err 611 } 612 defer mi.Close() 613 bs := bufio.NewScanner(mi) 614 wantPrefix := []byte(fmt.Sprintf("%v ", mountID)) 615 for bs.Scan() { 616 if !bytes.HasPrefix(bs.Bytes(), wantPrefix) { 617 continue 618 } 619 fields := strings.Fields(bs.Text()) 620 dev := fields[4] 621 return os.Open(dev) 622 } 623 if err := bs.Err(); err != nil { 624 return nil, err 625 } 626 return nil, errors.New("mountID not found") 627} 628 629func TestEpoll(t *testing.T) { 630 efd, err := unix.EpollCreate1(unix.EPOLL_CLOEXEC) 631 if err != nil { 632 t.Fatalf("EpollCreate1: %v", err) 633 } 634 defer unix.Close(efd) 635 636 r, w, err := os.Pipe() 637 if err != nil { 638 t.Fatal(err) 639 } 640 defer r.Close() 641 defer w.Close() 642 643 fd := int(r.Fd()) 644 ev := unix.EpollEvent{Events: unix.EPOLLIN, Fd: int32(fd)} 645 646 err = unix.EpollCtl(efd, unix.EPOLL_CTL_ADD, fd, &ev) 647 if err != nil { 648 t.Fatalf("EpollCtl: %v", err) 649 } 650 651 if _, err := w.Write([]byte("HELLO GOPHER")); err != nil { 652 t.Fatal(err) 653 } 654 655 events := make([]unix.EpollEvent, 128) 656 n, err := unix.EpollWait(efd, events, 1) 657 if err != nil { 658 t.Fatalf("EpollWait: %v", err) 659 } 660 661 if n != 1 { 662 t.Errorf("EpollWait: wrong number of events: got %v, expected 1", n) 663 } 664 665 got := int(events[0].Fd) 666 if got != fd { 667 t.Errorf("EpollWait: wrong Fd in event: got %v, expected %v", got, fd) 668 } 669} 670 671func TestPrctlRetInt(t *testing.T) { 672 err := unix.Prctl(unix.PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) 673 if err != nil { 674 t.Skipf("Prctl: %v, skipping test", err) 675 } 676 v, err := unix.PrctlRetInt(unix.PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0) 677 if err != nil { 678 t.Fatalf("failed to perform prctl: %v", err) 679 } 680 if v != 1 { 681 t.Fatalf("unexpected return from prctl; got %v, expected %v", v, 1) 682 } 683} 684 685func TestTimerfd(t *testing.T) { 686 var now unix.Timespec 687 if err := unix.ClockGettime(unix.CLOCK_REALTIME, &now); err != nil { 688 t.Fatalf("ClockGettime: %v", err) 689 } 690 691 tfd, err := unix.TimerfdCreate(unix.CLOCK_REALTIME, 0) 692 if err == unix.ENOSYS { 693 t.Skip("timerfd_create system call not implemented") 694 } else if err != nil { 695 t.Fatalf("TimerfdCreate: %v", err) 696 } 697 defer unix.Close(tfd) 698 699 var timeSpec unix.ItimerSpec 700 if err := unix.TimerfdGettime(tfd, &timeSpec); err != nil { 701 t.Fatalf("TimerfdGettime: %v", err) 702 } 703 704 if timeSpec.Value.Nsec != 0 || timeSpec.Value.Sec != 0 { 705 t.Fatalf("TimerfdGettime: timer is already set, but shouldn't be") 706 } 707 708 timeSpec = unix.ItimerSpec{ 709 Interval: unix.NsecToTimespec(int64(time.Millisecond)), 710 Value: now, 711 } 712 713 if err := unix.TimerfdSettime(tfd, unix.TFD_TIMER_ABSTIME, &timeSpec, nil); err != nil { 714 t.Fatalf("TimerfdSettime: %v", err) 715 } 716 717 const totalTicks = 10 718 const bufferLength = 8 719 720 buffer := make([]byte, bufferLength) 721 722 var count uint64 = 0 723 for count < totalTicks { 724 n, err := unix.Read(tfd, buffer) 725 if err != nil { 726 t.Fatalf("Timerfd: %v", err) 727 } else if n != bufferLength { 728 t.Fatalf("Timerfd: got %d bytes from timerfd, expected %d bytes", n, bufferLength) 729 } 730 731 count += *(*uint64)(unsafe.Pointer(&buffer)) 732 } 733} 734 735func TestOpenat2(t *testing.T) { 736 how := &unix.OpenHow{ 737 Flags: unix.O_RDONLY, 738 } 739 fd, err := unix.Openat2(unix.AT_FDCWD, ".", how) 740 if err != nil { 741 if err == unix.ENOSYS || err == unix.EPERM { 742 t.Skipf("openat2: %v (old kernel? need Linux >= 5.6)", err) 743 } 744 t.Fatalf("openat2: %v", err) 745 } 746 if err := unix.Close(fd); err != nil { 747 t.Fatalf("close: %v", err) 748 } 749 750 // prepare 751 tempDir, err := ioutil.TempDir("", t.Name()) 752 if err != nil { 753 t.Fatal(err) 754 } 755 defer os.RemoveAll(tempDir) 756 757 subdir := filepath.Join(tempDir, "dir") 758 if err := os.Mkdir(subdir, 0755); err != nil { 759 t.Fatal(err) 760 } 761 symlink := filepath.Join(subdir, "symlink") 762 if err := os.Symlink("../", symlink); err != nil { 763 t.Fatal(err) 764 } 765 766 dirfd, err := unix.Open(subdir, unix.O_RDONLY, 0) 767 if err != nil { 768 t.Fatalf("open(%q): %v", subdir, err) 769 } 770 defer unix.Close(dirfd) 771 772 // openat2 with no extra flags -- should succeed 773 fd, err = unix.Openat2(dirfd, "symlink", how) 774 if err != nil { 775 t.Errorf("Openat2 should succeed, got %v", err) 776 } 777 if err := unix.Close(fd); err != nil { 778 t.Fatalf("close: %v", err) 779 } 780 781 // open with RESOLVE_BENEATH, should result in EXDEV 782 how.Resolve = unix.RESOLVE_BENEATH 783 fd, err = unix.Openat2(dirfd, "symlink", how) 784 if err == nil { 785 if err := unix.Close(fd); err != nil { 786 t.Fatalf("close: %v", err) 787 } 788 } 789 if err != unix.EXDEV { 790 t.Errorf("Openat2 should fail with EXDEV, got %v", err) 791 } 792} 793