.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/unix/syscall_linux_test.go

   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
   7 package unix_test
   8
   9 import (
  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
  28 func 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
  43 func 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
  62 func 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
  77 func 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
  93 func 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
 127 func 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
 155 func 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
 179 func 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
 221 func 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         var took time.Duration
 238         for {
 239                 // On some platforms (e.g. Linux), the passed-in timespec is
 240                 // updated by pselect(2). Make sure to reset to the full
 241                 // duration in case of an EINTR.
 242                 ts := unix.NsecToTimespec(int64(dur))
 243                 start := time.Now()
 244                 n, err := unix.Pselect(0, nil, nil, nil, &ts, nil)
 245                 took = time.Since(start)
 246                 if err == unix.EINTR {
 247                         t.Logf("Pselect interrupted after %v", took)
 248                         continue
 249                 } else if err != nil {
 250                         t.Fatalf("Pselect: %v", err)
 251                 }
 252                 if n != 0 {
 253                         t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n)
 254                 }
 255                 break
 256         }
 257
 258         // On some builder the actual timeout might also be slightly less than the requested.
 259         // Add an acceptable margin to avoid flaky tests.
 260         if took < dur*2/3 {
 261                 t.Errorf("Pselect: got %v timeout, expected at least %v", took, dur)
 262         }
 263 }
 264
 265 func TestSchedSetaffinity(t *testing.T) {
 266         var newMask unix.CPUSet
 267         newMask.Zero()
 268         if newMask.Count() != 0 {
 269                 t.Errorf("CpuZero: didn't zero CPU set: %v", newMask)
 270         }
 271         cpu := 1
 272         newMask.Set(cpu)
 273         if newMask.Count() != 1 || !newMask.IsSet(cpu) {
 274                 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
 275         }
 276         cpu = 5
 277         newMask.Set(cpu)
 278         if newMask.Count() != 2 || !newMask.IsSet(cpu) {
 279                 t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
 280         }
 281         newMask.Clear(cpu)
 282         if newMask.Count() != 1 || newMask.IsSet(cpu) {
 283                 t.Errorf("CpuClr: didn't clear CPU %d in set: %v", cpu, newMask)
 284         }
 285
 286         runtime.LockOSThread()
 287         defer runtime.UnlockOSThread()
 288
 289         var oldMask unix.CPUSet
 290         err := unix.SchedGetaffinity(0, &oldMask)
 291         if err != nil {
 292                 t.Fatalf("SchedGetaffinity: %v", err)
 293         }
 294
 295         if runtime.NumCPU() < 2 {
 296                 t.Skip("skipping setaffinity tests on single CPU system")
 297         }
 298         if runtime.GOOS == "android" {
 299                 t.Skip("skipping setaffinity tests on android")
 300         }
 301
 302         // On a system like ppc64x where some cores can be disabled using ppc64_cpu,
 303         // setaffinity should only be called with enabled cores. The valid cores
 304         // are found from the oldMask, but if none are found then the setaffinity
 305         // tests are skipped. Issue #27875.
 306         cpu = 1
 307         if !oldMask.IsSet(cpu) {
 308                 newMask.Zero()
 309                 for i := 0; i < len(oldMask); i++ {
 310                         if oldMask.IsSet(i) {
 311                                 newMask.Set(i)
 312                                 break
 313                         }
 314                 }
 315                 if newMask.Count() == 0 {
 316                         t.Skip("skipping setaffinity tests if CPU not available")
 317                 }
 318         }
 319
 320         err = unix.SchedSetaffinity(0, &newMask)
 321         if err != nil {
 322                 t.Fatalf("SchedSetaffinity: %v", err)
 323         }
 324
 325         var gotMask unix.CPUSet
 326         err = unix.SchedGetaffinity(0, &gotMask)
 327         if err != nil {
 328                 t.Fatalf("SchedGetaffinity: %v", err)
 329         }
 330
 331         if gotMask != newMask {
 332                 t.Errorf("SchedSetaffinity: returned affinity mask does not match set affinity mask")
 333         }
 334
 335         // Restore old mask so it doesn't affect successive tests
 336         err = unix.SchedSetaffinity(0, &oldMask)
 337         if err != nil {
 338                 t.Fatalf("SchedSetaffinity: %v", err)
 339         }
 340 }
 341
 342 func TestStatx(t *testing.T) {
 343         var stx unix.Statx_t
 344         err := unix.Statx(unix.AT_FDCWD, ".", 0, 0, &stx)
 345         if err == unix.ENOSYS || err == unix.EPERM {
 346                 t.Skip("statx syscall is not available, skipping test")
 347         } else if err != nil {
 348                 t.Fatalf("Statx: %v", err)
 349         }
 350
 351         defer chtmpdir(t)()
 352         touch(t, "file1")
 353
 354         var st unix.Stat_t
 355         err = unix.Stat("file1", &st)
 356         if err != nil {
 357                 t.Fatalf("Stat: %v", err)
 358         }
 359
 360         flags := unix.AT_STATX_SYNC_AS_STAT
 361         err = unix.Statx(unix.AT_FDCWD, "file1", flags, unix.STATX_ALL, &stx)
 362         if err != nil {
 363                 t.Fatalf("Statx: %v", err)
 364         }
 365
 366         if uint32(stx.Mode) != st.Mode {
 367                 t.Errorf("Statx: returned stat mode does not match Stat")
 368         }
 369
 370         ctime := unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
 371         mtime := unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
 372
 373         if stx.Ctime != ctime {
 374                 t.Errorf("Statx: returned stat ctime does not match Stat")
 375         }
 376         if stx.Mtime != mtime {
 377                 t.Errorf("Statx: returned stat mtime does not match Stat")
 378         }
 379
 380         err = os.Symlink("file1", "symlink1")
 381         if err != nil {
 382                 t.Fatal(err)
 383         }
 384
 385         err = unix.Lstat("symlink1", &st)
 386         if err != nil {
 387                 t.Fatalf("Lstat: %v", err)
 388         }
 389
 390         err = unix.Statx(unix.AT_FDCWD, "symlink1", flags, unix.STATX_BASIC_STATS, &stx)
 391         if err != nil {
 392                 t.Fatalf("Statx: %v", err)
 393         }
 394
 395         // follow symlink, expect a regulat file
 396         if stx.Mode&unix.S_IFREG == 0 {
 397                 t.Errorf("Statx: didn't follow symlink")
 398         }
 399
 400         err = unix.Statx(unix.AT_FDCWD, "symlink1", flags|unix.AT_SYMLINK_NOFOLLOW, unix.STATX_ALL, &stx)
 401         if err != nil {
 402                 t.Fatalf("Statx: %v", err)
 403         }
 404
 405         // follow symlink, expect a symlink
 406         if stx.Mode&unix.S_IFLNK == 0 {
 407                 t.Errorf("Statx: unexpectedly followed symlink")
 408         }
 409         if uint32(stx.Mode) != st.Mode {
 410                 t.Errorf("Statx: returned stat mode does not match Lstat")
 411         }
 412
 413         ctime = unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
 414         mtime = unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
 415
 416         if stx.Ctime != ctime {
 417                 t.Errorf("Statx: returned stat ctime does not match Lstat")
 418         }
 419         if stx.Mtime != mtime {
 420                 t.Errorf("Statx: returned stat mtime does not match Lstat")
 421         }
 422 }
 423
 424 // stringsFromByteSlice converts a sequence of attributes to a []string.
 425 // On Linux, each entry is a NULL-terminated string.
 426 func stringsFromByteSlice(buf []byte) []string {
 427         var result []string
 428         off := 0
 429         for i, b := range buf {
 430                 if b == 0 {
 431                         result = append(result, string(buf[off:i]))
 432                         off = i + 1
 433                 }
 434         }
 435         return result
 436 }
 437
 438 func TestFaccessat(t *testing.T) {
 439         defer chtmpdir(t)()
 440         touch(t, "file1")
 441
 442         err := unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 0)
 443         if err != nil {
 444                 t.Errorf("Faccessat: unexpected error: %v", err)
 445         }
 446
 447         err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 2)
 448         if err != unix.EINVAL {
 449                 t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err)
 450         }
 451
 452         err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_EACCESS)
 453         if err != nil {
 454                 t.Errorf("Faccessat: unexpected error: %v", err)
 455         }
 456
 457         err = os.Symlink("file1", "symlink1")
 458         if err != nil {
 459                 t.Fatal(err)
 460         }
 461
 462         err = unix.Faccessat(unix.AT_FDCWD, "symlink1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW)
 463         if err != nil {
 464                 t.Errorf("Faccessat SYMLINK_NOFOLLOW: unexpected error %v", err)
 465         }
 466
 467         // We can't really test AT_SYMLINK_NOFOLLOW, because there
 468         // doesn't seem to be any way to change the mode of a symlink.
 469         // We don't test AT_EACCESS because such tests are only
 470         // meaningful if run as root.
 471
 472         err = unix.Fchmodat(unix.AT_FDCWD, "file1", 0, 0)
 473         if err != nil {
 474                 t.Errorf("Fchmodat: unexpected error %v", err)
 475         }
 476
 477         err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.F_OK, unix.AT_SYMLINK_NOFOLLOW)
 478         if err != nil {
 479                 t.Errorf("Faccessat: unexpected error: %v", err)
 480         }
 481
 482         err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW)
 483         if err != unix.EACCES {
 484                 if unix.Getuid() != 0 {
 485                         t.Errorf("Faccessat: unexpected error: %v, want EACCES", err)
 486                 }
 487         }
 488 }
 489
 490 func TestSyncFileRange(t *testing.T) {
 491         file, err := ioutil.TempFile("", "TestSyncFileRange")
 492         if err != nil {
 493                 t.Fatal(err)
 494         }
 495         defer os.Remove(file.Name())
 496         defer file.Close()
 497
 498         err = unix.SyncFileRange(int(file.Fd()), 0, 0, 0)
 499         if err == unix.ENOSYS || err == unix.EPERM {
 500                 t.Skip("sync_file_range syscall is not available, skipping test")
 501         } else if err != nil {
 502                 t.Fatalf("SyncFileRange: %v", err)
 503         }
 504
 505         // invalid flags
 506         flags := 0xf00
 507         err = unix.SyncFileRange(int(file.Fd()), 0, 0, flags)
 508         if err != unix.EINVAL {
 509                 t.Fatalf("SyncFileRange: unexpected error: %v, want EINVAL", err)
 510         }
 511 }
 512
 513 func TestClockNanosleep(t *testing.T) {
 514         delay := 50 * time.Millisecond
 515
 516         // Relative timespec.
 517         start := time.Now()
 518         rel := unix.NsecToTimespec(delay.Nanoseconds())
 519         remain := unix.Timespec{}
 520         for {
 521                 err := unix.ClockNanosleep(unix.CLOCK_MONOTONIC, 0, &rel, &remain)
 522                 if err == unix.ENOSYS || err == unix.EPERM {
 523                         t.Skip("clock_nanosleep syscall is not available, skipping test")
 524                 } else if err == unix.EINTR {
 525                         t.Logf("ClockNanosleep interrupted after %v", time.Since(start))
 526                         rel = remain
 527                         continue
 528                 } else if err != nil {
 529                         t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) = %v", &rel, err)
 530                 } else if slept := time.Since(start); slept < delay {
 531                         t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) slept only %v", &rel, slept)
 532                 }
 533                 break
 534         }
 535
 536         // Absolute timespec.
 537         for {
 538                 start = time.Now()
 539                 until := start.Add(delay)
 540                 abs := unix.NsecToTimespec(until.UnixNano())
 541                 err := unix.ClockNanosleep(unix.CLOCK_REALTIME, unix.TIMER_ABSTIME, &abs, nil)
 542                 if err == unix.EINTR {
 543                         t.Logf("ClockNanosleep interrupted after %v", time.Since(start))
 544                         continue
 545                 } else if err != nil {
 546                         t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) = %v", &abs, until, err)
 547                 } else if slept := time.Since(start); slept < delay {
 548                         t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) slept only %v", &abs, until, slept)
 549                 }
 550                 break
 551         }
 552
 553         // Invalid clock. clock_nanosleep(2) says EINVAL, but it’s actually EOPNOTSUPP.
 554         err := unix.ClockNanosleep(unix.CLOCK_THREAD_CPUTIME_ID, 0, &rel, nil)
 555         if err != unix.EINVAL && err != unix.EOPNOTSUPP {
 556                 t.Errorf("ClockNanosleep(CLOCK_THREAD_CPUTIME_ID, 0, %#v, nil) = %v, want EINVAL or EOPNOTSUPP", &rel, err)
 557         }
 558 }
 559
 560 func TestOpenByHandleAt(t *testing.T) {
 561         skipIfNotSupported := func(t *testing.T, name string, err error) {
 562                 if err == unix.EPERM {
 563                         t.Skipf("skipping %s test without CAP_DAC_READ_SEARCH", name)
 564                 }
 565                 if err == unix.ENOSYS {
 566                         t.Skipf("%s system call not available", name)
 567                 }
 568                 if err == unix.EOPNOTSUPP {
 569                         t.Skipf("%s not supported on this filesystem", name)
 570                 }
 571         }
 572
 573         h, mountID, err := unix.NameToHandleAt(unix.AT_FDCWD, "syscall_linux_test.go", 0)
 574         if err != nil {
 575                 skipIfNotSupported(t, "name_to_handle_at", err)
 576                 t.Fatalf("NameToHandleAt: %v", err)
 577         }
 578         t.Logf("mountID: %v, handle: size=%d, type=%d, bytes=%q", mountID,
 579                 h.Size(), h.Type(), h.Bytes())
 580         mount, err := openMountByID(mountID)
 581         if err != nil {
 582                 t.Fatalf("openMountByID: %v", err)
 583         }
 584         defer mount.Close()
 585
 586         for _, clone := range []bool{false, true} {
 587                 t.Run("clone="+strconv.FormatBool(clone), func(t *testing.T) {
 588                         if clone {
 589                                 h = unix.NewFileHandle(h.Type(), h.Bytes())
 590                         }
 591                         fd, err := unix.OpenByHandleAt(int(mount.Fd()), h, unix.O_RDONLY)
 592                         skipIfNotSupported(t, "open_by_handle_at", err)
 593                         if err != nil {
 594                                 t.Fatalf("OpenByHandleAt: %v", err)
 595                         }
 596                         defer unix.Close(fd)
 597
 598                         t.Logf("opened fd %v", fd)
 599                         f := os.NewFile(uintptr(fd), "")
 600                         slurp, err := ioutil.ReadAll(f)
 601                         if err != nil {
 602                                 t.Fatal(err)
 603                         }
 604                         const substr = "Some substring for a test."
 605                         if !strings.Contains(string(slurp), substr) {
 606                                 t.Errorf("didn't find substring %q in opened file; read %d bytes", substr, len(slurp))
 607                         }
 608                 })
 609         }
 610 }
 611
 612 func openMountByID(mountID int) (f *os.File, err error) {
 613         mi, err := os.Open("/proc/self/mountinfo")
 614         if err != nil {
 615                 return nil, err
 616         }
 617         defer mi.Close()
 618         bs := bufio.NewScanner(mi)
 619         wantPrefix := []byte(fmt.Sprintf("%v ", mountID))
 620         for bs.Scan() {
 621                 if !bytes.HasPrefix(bs.Bytes(), wantPrefix) {
 622                         continue
 623                 }
 624                 fields := strings.Fields(bs.Text())
 625                 dev := fields[4]
 626                 return os.Open(dev)
 627         }
 628         if err := bs.Err(); err != nil {
 629                 return nil, err
 630         }
 631         return nil, errors.New("mountID not found")
 632 }
 633
 634 func TestEpoll(t *testing.T) {
 635         efd, err := unix.EpollCreate1(unix.EPOLL_CLOEXEC)
 636         if err != nil {
 637                 t.Fatalf("EpollCreate1: %v", err)
 638         }
 639         defer unix.Close(efd)
 640
 641         r, w, err := os.Pipe()
 642         if err != nil {
 643                 t.Fatal(err)
 644         }
 645         defer r.Close()
 646         defer w.Close()
 647
 648         fd := int(r.Fd())
 649         ev := unix.EpollEvent{Events: unix.EPOLLIN, Fd: int32(fd)}
 650
 651         err = unix.EpollCtl(efd, unix.EPOLL_CTL_ADD, fd, &ev)
 652         if err != nil {
 653                 t.Fatalf("EpollCtl: %v", err)
 654         }
 655
 656         if _, err := w.Write([]byte("HELLO GOPHER")); err != nil {
 657                 t.Fatal(err)
 658         }
 659
 660         events := make([]unix.EpollEvent, 128)
 661         n, err := unix.EpollWait(efd, events, 1)
 662         if err != nil {
 663                 t.Fatalf("EpollWait: %v", err)
 664         }
 665
 666         if n != 1 {
 667                 t.Errorf("EpollWait: wrong number of events: got %v, expected 1", n)
 668         }
 669
 670         got := int(events[0].Fd)
 671         if got != fd {
 672                 t.Errorf("EpollWait: wrong Fd in event: got %v, expected %v", got, fd)
 673         }
 674 }
 675
 676 func TestPrctlRetInt(t *testing.T) {
 677         err := unix.Prctl(unix.PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)
 678         if err != nil {
 679                 t.Skipf("Prctl: %v, skipping test", err)
 680         }
 681         v, err := unix.PrctlRetInt(unix.PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0)
 682         if err != nil {
 683                 t.Fatalf("failed to perform prctl: %v", err)
 684         }
 685         if v != 1 {
 686                 t.Fatalf("unexpected return from prctl; got %v, expected %v", v, 1)
 687         }
 688 }
 689
 690 func TestTimerfd(t *testing.T) {
 691         var now unix.Timespec
 692         if err := unix.ClockGettime(unix.CLOCK_REALTIME, &now); err != nil {
 693                 t.Fatalf("ClockGettime: %v", err)
 694         }
 695
 696         tfd, err := unix.TimerfdCreate(unix.CLOCK_REALTIME, 0)
 697         if err == unix.ENOSYS {
 698                 t.Skip("timerfd_create system call not implemented")
 699         } else if err != nil {
 700                 t.Fatalf("TimerfdCreate: %v", err)
 701         }
 702         defer unix.Close(tfd)
 703
 704         var timeSpec unix.ItimerSpec
 705         if err := unix.TimerfdGettime(tfd, &timeSpec); err != nil {
 706                 t.Fatalf("TimerfdGettime: %v", err)
 707         }
 708
 709         if timeSpec.Value.Nsec != 0 || timeSpec.Value.Sec != 0 {
 710                 t.Fatalf("TimerfdGettime: timer is already set, but shouldn't be")
 711         }
 712
 713         timeSpec = unix.ItimerSpec{
 714                 Interval: unix.NsecToTimespec(int64(time.Millisecond)),
 715                 Value:    now,
 716         }
 717
 718         if err := unix.TimerfdSettime(tfd, unix.TFD_TIMER_ABSTIME, &timeSpec, nil); err != nil {
 719                 t.Fatalf("TimerfdSettime: %v", err)
 720         }
 721
 722         const totalTicks = 10
 723         const bufferLength = 8
 724
 725         buffer := make([]byte, bufferLength)
 726
 727         var count uint64 = 0
 728         for count < totalTicks {
 729                 n, err := unix.Read(tfd, buffer)
 730                 if err != nil {
 731                         t.Fatalf("Timerfd: %v", err)
 732                 } else if n != bufferLength {
 733                         t.Fatalf("Timerfd: got %d bytes from timerfd, expected %d bytes", n, bufferLength)
 734                 }
 735
 736                 count += *(*uint64)(unsafe.Pointer(&buffer))
 737         }
 738 }
 739
 740 func TestOpenat2(t *testing.T) {
 741         how := &unix.OpenHow{
 742                 Flags: unix.O_RDONLY,
 743         }
 744         fd, err := unix.Openat2(unix.AT_FDCWD, ".", how)
 745         if err != nil {
 746                 if err == unix.ENOSYS || err == unix.EPERM {
 747                         t.Skipf("openat2: %v (old kernel? need Linux >= 5.6)", err)
 748                 }
 749                 t.Fatalf("openat2: %v", err)
 750         }
 751         if err := unix.Close(fd); err != nil {
 752                 t.Fatalf("close: %v", err)
 753         }
 754
 755         // prepare
 756         tempDir, err := ioutil.TempDir("", t.Name())
 757         if err != nil {
 758                 t.Fatal(err)
 759         }
 760         defer os.RemoveAll(tempDir)
 761
 762         subdir := filepath.Join(tempDir, "dir")
 763         if err := os.Mkdir(subdir, 0755); err != nil {
 764                 t.Fatal(err)
 765         }
 766         symlink := filepath.Join(subdir, "symlink")
 767         if err := os.Symlink("../", symlink); err != nil {
 768                 t.Fatal(err)
 769         }
 770
 771         dirfd, err := unix.Open(subdir, unix.O_RDONLY, 0)
 772         if err != nil {
 773                 t.Fatalf("open(%q): %v", subdir, err)
 774         }
 775         defer unix.Close(dirfd)
 776
 777         // openat2 with no extra flags -- should succeed
 778         fd, err = unix.Openat2(dirfd, "symlink", how)
 779         if err != nil {
 780                 t.Errorf("Openat2 should succeed, got %v", err)
 781         }
 782         if err := unix.Close(fd); err != nil {
 783                 t.Fatalf("close: %v", err)
 784         }
 785
 786         // open with RESOLVE_BENEATH, should result in EXDEV
 787         how.Resolve = unix.RESOLVE_BENEATH
 788         fd, err = unix.Openat2(dirfd, "symlink", how)
 789         if err == nil {
 790                 if err := unix.Close(fd); err != nil {
 791                         t.Fatalf("close: %v", err)
 792                 }
 793         }
 794         if err != unix.EXDEV {
 795                 t.Errorf("Openat2 should fail with EXDEV, got %v", err)
 796         }
 797 }