syscall_linux_test.go

Documentation: golang.org/x/sys/unix

     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  
     7  package unix_test
     8  
     9  import (
    10  	"bufio"
    11  	"bytes"
    12  	"encoding/hex"
    13  	"errors"
    14  	"fmt"
    15  	"io"
    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  	chtmpdir(t)
   281  	f := mktmpfifo(t)
   282  
   283  	const timeout = 100 * time.Millisecond
   284  
   285  	ok := make(chan bool, 1)
   286  	go func() {
   287  		select {
   288  		case <-time.After(10 * timeout):
   289  			t.Errorf("Ppoll: failed to timeout after %d", 10*timeout)
   290  		case <-ok:
   291  		}
   292  	}()
   293  
   294  	fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}}
   295  	timeoutTs := unix.NsecToTimespec(int64(timeout))
   296  	n, err := unix.Ppoll(fds, &timeoutTs, nil)
   297  	ok <- true
   298  	if err != nil {
   299  		t.Errorf("Ppoll: unexpected error: %v", err)
   300  		return
   301  	}
   302  	if n != 0 {
   303  		t.Errorf("Ppoll: wrong number of events: got %v, expected %v", n, 0)
   304  		return
   305  	}
   306  }
   307  
   308  func TestTime(t *testing.T) {
   309  	var ut unix.Time_t
   310  	ut2, err := unix.Time(&ut)
   311  	if err != nil {
   312  		t.Fatalf("Time: %v", err)
   313  	}
   314  	if ut != ut2 {
   315  		t.Errorf("Time: return value %v should be equal to argument %v", ut2, ut)
   316  	}
   317  
   318  	var now time.Time
   319  
   320  	for i := 0; i < 10; i++ {
   321  		ut, err = unix.Time(nil)
   322  		if err != nil {
   323  			t.Fatalf("Time: %v", err)
   324  		}
   325  
   326  		now = time.Now()
   327  		diff := int64(ut) - now.Unix()
   328  		if -1 <= diff && diff <= 1 {
   329  			return
   330  		}
   331  	}
   332  
   333  	t.Errorf("Time: return value %v should be nearly equal to time.Now().Unix() %v±1", ut, now.Unix())
   334  }
   335  
   336  func TestUtime(t *testing.T) {
   337  	chtmpdir(t)
   338  
   339  	touch(t, "file1")
   340  
   341  	buf := &unix.Utimbuf{
   342  		Modtime: 12345,
   343  	}
   344  
   345  	err := unix.Utime("file1", buf)
   346  	if err != nil {
   347  		t.Fatalf("Utime: %v", err)
   348  	}
   349  
   350  	fi, err := os.Stat("file1")
   351  	if err != nil {
   352  		t.Fatal(err)
   353  	}
   354  
   355  	if fi.ModTime().Unix() != 12345 {
   356  		t.Errorf("Utime: failed to change modtime: expected %v, got %v", 12345, fi.ModTime().Unix())
   357  	}
   358  }
   359  
   360  func TestRlimitAs(t *testing.T) {
   361  	// disable GC during to avoid flaky test
   362  	defer debug.SetGCPercent(debug.SetGCPercent(-1))
   363  
   364  	var rlim unix.Rlimit
   365  	err := unix.Getrlimit(unix.RLIMIT_AS, &rlim)
   366  	if err != nil {
   367  		t.Fatalf("Getrlimit: %v", err)
   368  	}
   369  	var zero unix.Rlimit
   370  	if zero == rlim {
   371  		t.Fatalf("Getrlimit: got zero value %#v", rlim)
   372  	}
   373  	set := rlim
   374  	set.Cur = uint64(unix.Getpagesize())
   375  	err = unix.Setrlimit(unix.RLIMIT_AS, &set)
   376  	if err != nil {
   377  		t.Fatalf("Setrlimit: set failed: %#v %v", set, err)
   378  	}
   379  
   380  	// RLIMIT_AS was set to the page size, so mmap()'ing twice the page size
   381  	// should fail. See 'man 2 getrlimit'.
   382  	_, err = unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
   383  	if err == nil {
   384  		t.Fatal("Mmap: unexpectedly succeeded after setting RLIMIT_AS")
   385  	}
   386  
   387  	err = unix.Setrlimit(unix.RLIMIT_AS, &rlim)
   388  	if err != nil {
   389  		t.Fatalf("Setrlimit: restore failed: %#v %v", rlim, err)
   390  	}
   391  
   392  	b, err := unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
   393  	if err != nil {
   394  		t.Fatalf("Mmap: %v", err)
   395  	}
   396  	err = unix.Munmap(b)
   397  	if err != nil {
   398  		t.Fatalf("Munmap: %v", err)
   399  	}
   400  }
   401  
   402  func TestPselect(t *testing.T) {
   403  	for {
   404  		n, err := unix.Pselect(0, nil, nil, nil, &unix.Timespec{Sec: 0, Nsec: 0}, nil)
   405  		if err == unix.EINTR {
   406  			t.Logf("Pselect interrupted")
   407  			continue
   408  		} else if err != nil {
   409  			t.Fatalf("Pselect: %v", err)
   410  		}
   411  		if n != 0 {
   412  			t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n)
   413  		}
   414  		break
   415  	}
   416  
   417  	dur := 2500 * time.Microsecond
   418  	var took time.Duration
   419  	for {
   420  		// On some platforms (e.g. Linux), the passed-in timespec is
   421  		// updated by pselect(2). Make sure to reset to the full
   422  		// duration in case of an EINTR.
   423  		ts := unix.NsecToTimespec(int64(dur))
   424  		start := time.Now()
   425  		n, err := unix.Pselect(0, nil, nil, nil, &ts, nil)
   426  		took = time.Since(start)
   427  		if err == unix.EINTR {
   428  			t.Logf("Pselect interrupted after %v", took)
   429  			continue
   430  		} else if err != nil {
   431  			t.Fatalf("Pselect: %v", err)
   432  		}
   433  		if n != 0 {
   434  			t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n)
   435  		}
   436  		break
   437  	}
   438  
   439  	// On some builder the actual timeout might also be slightly less than the requested.
   440  	// Add an acceptable margin to avoid flaky tests.
   441  	if took < dur*2/3 {
   442  		t.Errorf("Pselect: got %v timeout, expected at least %v", took, dur)
   443  	}
   444  }
   445  
   446  func TestPselectWithSigmask(t *testing.T) {
   447  	var sigmask unix.Sigset_t
   448  	sigmask.Val[0] |= 1 << (uint(unix.SIGUSR1) - 1)
   449  	for {
   450  		n, err := unix.Pselect(0, nil, nil, nil, &unix.Timespec{Sec: 0, Nsec: 0}, &sigmask)
   451  		if err == unix.EINTR {
   452  			t.Logf("Pselect interrupted")
   453  			continue
   454  		} else if err != nil {
   455  			t.Fatalf("Pselect: %v", err)
   456  		}
   457  		if n != 0 {
   458  			t.Fatalf("Pselect: got %v ready file descriptors, expected 0", n)
   459  		}
   460  		break
   461  	}
   462  }
   463  
   464  func TestSchedSetaffinity(t *testing.T) {
   465  	var newMask unix.CPUSet
   466  	newMask.Zero()
   467  	if newMask.Count() != 0 {
   468  		t.Errorf("CpuZero: didn't zero CPU set: %v", newMask)
   469  	}
   470  	cpu := 1
   471  	newMask.Set(cpu)
   472  	if newMask.Count() != 1 || !newMask.IsSet(cpu) {
   473  		t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
   474  	}
   475  	cpu = 5
   476  	newMask.Set(cpu)
   477  	if newMask.Count() != 2 || !newMask.IsSet(cpu) {
   478  		t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
   479  	}
   480  	newMask.Clear(cpu)
   481  	if newMask.Count() != 1 || newMask.IsSet(cpu) {
   482  		t.Errorf("CpuClr: didn't clear CPU %d in set: %v", cpu, newMask)
   483  	}
   484  
   485  	runtime.LockOSThread()
   486  	defer runtime.UnlockOSThread()
   487  
   488  	var oldMask unix.CPUSet
   489  	err := unix.SchedGetaffinity(0, &oldMask)
   490  	if err != nil {
   491  		t.Fatalf("SchedGetaffinity: %v", err)
   492  	}
   493  
   494  	if runtime.NumCPU() < 2 {
   495  		t.Skip("skipping setaffinity tests on single CPU system")
   496  	}
   497  	if runtime.GOOS == "android" {
   498  		t.Skip("skipping setaffinity tests on android")
   499  	}
   500  
   501  	// On a system like ppc64x where some cores can be disabled using ppc64_cpu,
   502  	// setaffinity should only be called with enabled cores. The valid cores
   503  	// are found from the oldMask, but if none are found then the setaffinity
   504  	// tests are skipped. Issue #27875.
   505  	cpu = 1
   506  	if !oldMask.IsSet(cpu) {
   507  		newMask.Zero()
   508  		for i := 0; i < len(oldMask); i++ {
   509  			if oldMask.IsSet(i) {
   510  				newMask.Set(i)
   511  				break
   512  			}
   513  		}
   514  		if newMask.Count() == 0 {
   515  			t.Skip("skipping setaffinity tests if CPU not available")
   516  		}
   517  	}
   518  
   519  	err = unix.SchedSetaffinity(0, &newMask)
   520  	if err != nil {
   521  		t.Fatalf("SchedSetaffinity: %v", err)
   522  	}
   523  
   524  	var gotMask unix.CPUSet
   525  	err = unix.SchedGetaffinity(0, &gotMask)
   526  	if err != nil {
   527  		t.Fatalf("SchedGetaffinity: %v", err)
   528  	}
   529  
   530  	if gotMask != newMask {
   531  		t.Errorf("SchedSetaffinity: returned affinity mask does not match set affinity mask")
   532  	}
   533  
   534  	// Restore old mask so it doesn't affect successive tests
   535  	err = unix.SchedSetaffinity(0, &oldMask)
   536  	if err != nil {
   537  		t.Fatalf("SchedSetaffinity: %v", err)
   538  	}
   539  }
   540  
   541  func TestStatx(t *testing.T) {
   542  	var stx unix.Statx_t
   543  	err := unix.Statx(unix.AT_FDCWD, ".", 0, 0, &stx)
   544  	if err == unix.ENOSYS || err == unix.EPERM {
   545  		t.Skip("statx syscall is not available, skipping test")
   546  	} else if err != nil {
   547  		t.Fatalf("Statx: %v", err)
   548  	}
   549  
   550  	chtmpdir(t)
   551  	touch(t, "file1")
   552  
   553  	var st unix.Stat_t
   554  	err = unix.Stat("file1", &st)
   555  	if err != nil {
   556  		t.Fatalf("Stat: %v", err)
   557  	}
   558  
   559  	flags := unix.AT_STATX_SYNC_AS_STAT
   560  	err = unix.Statx(unix.AT_FDCWD, "file1", flags, unix.STATX_ALL, &stx)
   561  	if err != nil {
   562  		t.Fatalf("Statx: %v", err)
   563  	}
   564  
   565  	if uint32(stx.Mode) != st.Mode {
   566  		t.Errorf("Statx: returned stat mode does not match Stat")
   567  	}
   568  
   569  	ctime := unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
   570  	mtime := unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
   571  
   572  	if stx.Ctime != ctime {
   573  		t.Errorf("Statx: returned stat ctime does not match Stat")
   574  	}
   575  	if stx.Mtime != mtime {
   576  		t.Errorf("Statx: returned stat mtime does not match Stat")
   577  	}
   578  
   579  	err = os.Symlink("file1", "symlink1")
   580  	if err != nil {
   581  		t.Fatal(err)
   582  	}
   583  
   584  	err = unix.Lstat("symlink1", &st)
   585  	if err != nil {
   586  		t.Fatalf("Lstat: %v", err)
   587  	}
   588  
   589  	err = unix.Statx(unix.AT_FDCWD, "symlink1", flags, unix.STATX_BASIC_STATS, &stx)
   590  	if err != nil {
   591  		t.Fatalf("Statx: %v", err)
   592  	}
   593  
   594  	// follow symlink, expect a regulat file
   595  	if stx.Mode&unix.S_IFREG == 0 {
   596  		t.Errorf("Statx: didn't follow symlink")
   597  	}
   598  
   599  	err = unix.Statx(unix.AT_FDCWD, "symlink1", flags|unix.AT_SYMLINK_NOFOLLOW, unix.STATX_ALL, &stx)
   600  	if err != nil {
   601  		t.Fatalf("Statx: %v", err)
   602  	}
   603  
   604  	// follow symlink, expect a symlink
   605  	if stx.Mode&unix.S_IFLNK == 0 {
   606  		t.Errorf("Statx: unexpectedly followed symlink")
   607  	}
   608  	if uint32(stx.Mode) != st.Mode {
   609  		t.Errorf("Statx: returned stat mode does not match Lstat")
   610  	}
   611  
   612  	ctime = unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
   613  	mtime = unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
   614  
   615  	if stx.Ctime != ctime {
   616  		t.Errorf("Statx: returned stat ctime does not match Lstat")
   617  	}
   618  	if stx.Mtime != mtime {
   619  		t.Errorf("Statx: returned stat mtime does not match Lstat")
   620  	}
   621  }
   622  
   623  // stringsFromByteSlice converts a sequence of attributes to a []string.
   624  // On Linux, each entry is a NULL-terminated string.
   625  func stringsFromByteSlice(buf []byte) []string {
   626  	var result []string
   627  	off := 0
   628  	for i, b := range buf {
   629  		if b == 0 {
   630  			result = append(result, string(buf[off:i]))
   631  			off = i + 1
   632  		}
   633  	}
   634  	return result
   635  }
   636  
   637  func TestFaccessat(t *testing.T) {
   638  	chtmpdir(t)
   639  	touch(t, "file1")
   640  
   641  	err := unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 0)
   642  	if err != nil {
   643  		t.Errorf("Faccessat: unexpected error: %v", err)
   644  	}
   645  
   646  	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, 2)
   647  	if err != unix.EINVAL {
   648  		t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err)
   649  	}
   650  
   651  	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_EACCESS)
   652  	if err != nil {
   653  		t.Errorf("Faccessat: unexpected error: %v", err)
   654  	}
   655  
   656  	err = os.Symlink("file1", "symlink1")
   657  	if err != nil {
   658  		t.Fatal(err)
   659  	}
   660  
   661  	err = unix.Faccessat(unix.AT_FDCWD, "symlink1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW)
   662  	if err != nil {
   663  		t.Errorf("Faccessat SYMLINK_NOFOLLOW: unexpected error %v", err)
   664  	}
   665  
   666  	// We can't really test AT_SYMLINK_NOFOLLOW, because there
   667  	// doesn't seem to be any way to change the mode of a symlink.
   668  	// We don't test AT_EACCESS because such tests are only
   669  	// meaningful if run as root.
   670  
   671  	err = unix.Fchmodat(unix.AT_FDCWD, "file1", 0, 0)
   672  	if err != nil {
   673  		t.Errorf("Fchmodat: unexpected error %v", err)
   674  	}
   675  
   676  	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.F_OK, unix.AT_SYMLINK_NOFOLLOW)
   677  	if err != nil {
   678  		t.Errorf("Faccessat: unexpected error: %v", err)
   679  	}
   680  
   681  	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.R_OK, unix.AT_SYMLINK_NOFOLLOW)
   682  	if err != unix.EACCES {
   683  		if unix.Getuid() != 0 {
   684  			t.Errorf("Faccessat: unexpected error: %v, want EACCES", err)
   685  		}
   686  	}
   687  }
   688  
   689  func TestSyncFileRange(t *testing.T) {
   690  	file, err := os.Create(filepath.Join(t.TempDir(), t.Name()))
   691  	if err != nil {
   692  		t.Fatal(err)
   693  	}
   694  	defer file.Close()
   695  
   696  	err = unix.SyncFileRange(int(file.Fd()), 0, 0, 0)
   697  	if err == unix.ENOSYS || err == unix.EPERM {
   698  		t.Skip("sync_file_range syscall is not available, skipping test")
   699  	} else if err != nil {
   700  		t.Fatalf("SyncFileRange: %v", err)
   701  	}
   702  
   703  	// invalid flags
   704  	flags := 0xf00
   705  	err = unix.SyncFileRange(int(file.Fd()), 0, 0, flags)
   706  	if err != unix.EINVAL {
   707  		t.Fatalf("SyncFileRange: unexpected error: %v, want EINVAL", err)
   708  	}
   709  }
   710  
   711  func TestClockNanosleep(t *testing.T) {
   712  	delay := 50 * time.Millisecond
   713  
   714  	// Relative timespec.
   715  	start := time.Now()
   716  	rel := unix.NsecToTimespec(delay.Nanoseconds())
   717  	remain := unix.Timespec{}
   718  	for {
   719  		err := unix.ClockNanosleep(unix.CLOCK_MONOTONIC, 0, &rel, &remain)
   720  		if err == unix.ENOSYS || err == unix.EPERM {
   721  			t.Skip("clock_nanosleep syscall is not available, skipping test")
   722  		} else if err == unix.EINTR {
   723  			t.Logf("ClockNanosleep interrupted after %v", time.Since(start))
   724  			rel = remain
   725  			continue
   726  		} else if err != nil {
   727  			t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) = %v", &rel, err)
   728  		} else if slept := time.Since(start); slept < delay {
   729  			t.Errorf("ClockNanosleep(CLOCK_MONOTONIC, 0, %#v, nil) slept only %v", &rel, slept)
   730  		}
   731  		break
   732  	}
   733  
   734  	// Absolute timespec.
   735  	for {
   736  		start = time.Now()
   737  		until := start.Add(delay)
   738  		abs := unix.NsecToTimespec(until.UnixNano())
   739  		err := unix.ClockNanosleep(unix.CLOCK_REALTIME, unix.TIMER_ABSTIME, &abs, nil)
   740  		if err == unix.EINTR {
   741  			t.Logf("ClockNanosleep interrupted after %v", time.Since(start))
   742  			continue
   743  		} else if err != nil {
   744  			t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) = %v", &abs, until, err)
   745  		} else {
   746  			// We asked for CLOCK_REALTIME, but we have no way to know whether it
   747  			// jumped backward after ClockNanosleep returned. Compare both ways,
   748  			// and only fail if both the monotonic and wall clocks agree that
   749  			// the elapsed sleep was too short.
   750  			//
   751  			// This can still theoretically fail spuriously: if the clock jumps
   752  			// forward during ClockNanosleep and then backward again before we can
   753  			// call time.Now, then we could end up with a time that is too short on
   754  			// both the monotonic scale (because of the forward jump) and the
   755  			// real-time scale (because of the backward jump. However, it seems
   756  			// unlikely that two such contrary jumps will ever occur in the time it
   757  			// takes to execute this test.
   758  			if now := time.Now(); now.Before(until) && now.Round(0).Before(until) {
   759  				t.Errorf("ClockNanosleep(CLOCK_REALTIME, TIMER_ABSTIME, %#v (=%v), nil) slept only until %v", &abs, until, now)
   760  			}
   761  		}
   762  		break
   763  	}
   764  
   765  	// Invalid clock. clock_nanosleep(2) says EINVAL, but it’s actually EOPNOTSUPP.
   766  	err := unix.ClockNanosleep(unix.CLOCK_THREAD_CPUTIME_ID, 0, &rel, nil)
   767  	if err != unix.EINVAL && err != unix.EOPNOTSUPP {
   768  		t.Errorf("ClockNanosleep(CLOCK_THREAD_CPUTIME_ID, 0, %#v, nil) = %v, want EINVAL or EOPNOTSUPP", &rel, err)
   769  	}
   770  }
   771  
   772  func TestOpenByHandleAt(t *testing.T) {
   773  	skipIfNotSupported := func(t *testing.T, name string, err error) {
   774  		if err == unix.EPERM {
   775  			t.Skipf("skipping %s test without CAP_DAC_READ_SEARCH", name)
   776  		}
   777  		if err == unix.ENOSYS {
   778  			t.Skipf("%s system call not available", name)
   779  		}
   780  		if err == unix.EOPNOTSUPP {
   781  			t.Skipf("%s not supported on this filesystem", name)
   782  		}
   783  	}
   784  
   785  	h, mountID, err := unix.NameToHandleAt(unix.AT_FDCWD, "syscall_linux_test.go", 0)
   786  	if err != nil {
   787  		skipIfNotSupported(t, "name_to_handle_at", err)
   788  		t.Fatalf("NameToHandleAt: %v", err)
   789  	}
   790  	t.Logf("mountID: %v, handle: size=%d, type=%d, bytes=%q", mountID,
   791  		h.Size(), h.Type(), h.Bytes())
   792  	mount, err := openMountByID(mountID)
   793  	if err != nil {
   794  		t.Fatalf("openMountByID: %v", err)
   795  	}
   796  	defer mount.Close()
   797  
   798  	for _, clone := range []bool{false, true} {
   799  		t.Run("clone="+strconv.FormatBool(clone), func(t *testing.T) {
   800  			if clone {
   801  				h = unix.NewFileHandle(h.Type(), h.Bytes())
   802  			}
   803  			fd, err := unix.OpenByHandleAt(int(mount.Fd()), h, unix.O_RDONLY)
   804  			skipIfNotSupported(t, "open_by_handle_at", err)
   805  			if err != nil {
   806  				t.Fatalf("OpenByHandleAt: %v", err)
   807  			}
   808  			t.Logf("opened fd %v", fd)
   809  			f := os.NewFile(uintptr(fd), "")
   810  			defer f.Close()
   811  
   812  			slurp, err := io.ReadAll(f)
   813  			if err != nil {
   814  				t.Fatal(err)
   815  			}
   816  			const substr = "Some substring for a test."
   817  			if !strings.Contains(string(slurp), substr) {
   818  				t.Errorf("didn't find substring %q in opened file; read %d bytes", substr, len(slurp))
   819  			}
   820  		})
   821  	}
   822  }
   823  
   824  func openMountByID(mountID int) (f *os.File, err error) {
   825  	mi, err := os.Open("/proc/self/mountinfo")
   826  	if err != nil {
   827  		return nil, err
   828  	}
   829  	defer mi.Close()
   830  	bs := bufio.NewScanner(mi)
   831  	wantPrefix := []byte(fmt.Sprintf("%v ", mountID))
   832  	for bs.Scan() {
   833  		if !bytes.HasPrefix(bs.Bytes(), wantPrefix) {
   834  			continue
   835  		}
   836  		fields := strings.Fields(bs.Text())
   837  		dev := fields[4]
   838  		return os.Open(dev)
   839  	}
   840  	if err := bs.Err(); err != nil {
   841  		return nil, err
   842  	}
   843  	return nil, errors.New("mountID not found")
   844  }
   845  
   846  func TestEpoll(t *testing.T) {
   847  	efd, err := unix.EpollCreate1(unix.EPOLL_CLOEXEC)
   848  	if err != nil {
   849  		t.Fatalf("EpollCreate1: %v", err)
   850  	}
   851  	defer unix.Close(efd)
   852  
   853  	r, w, err := os.Pipe()
   854  	if err != nil {
   855  		t.Fatal(err)
   856  	}
   857  	defer r.Close()
   858  	defer w.Close()
   859  
   860  	fd := int(r.Fd())
   861  	ev := unix.EpollEvent{Events: unix.EPOLLIN, Fd: int32(fd)}
   862  
   863  	err = unix.EpollCtl(efd, unix.EPOLL_CTL_ADD, fd, &ev)
   864  	if err != nil {
   865  		t.Fatalf("EpollCtl: %v", err)
   866  	}
   867  
   868  	if _, err := w.Write([]byte("HELLO GOPHER")); err != nil {
   869  		t.Fatal(err)
   870  	}
   871  
   872  	events := make([]unix.EpollEvent, 128)
   873  	n, err := unix.EpollWait(efd, events, 1)
   874  	if err != nil {
   875  		t.Fatalf("EpollWait: %v", err)
   876  	}
   877  
   878  	if n != 1 {
   879  		t.Errorf("EpollWait: wrong number of events: got %v, expected 1", n)
   880  	}
   881  
   882  	got := int(events[0].Fd)
   883  	if got != fd {
   884  		t.Errorf("EpollWait: wrong Fd in event: got %v, expected %v", got, fd)
   885  	}
   886  }
   887  
   888  func TestPrctlRetInt(t *testing.T) {
   889  	skipc := make(chan bool, 1)
   890  	skip := func() {
   891  		skipc <- true
   892  		runtime.Goexit()
   893  	}
   894  
   895  	go func() {
   896  		// This test uses prctl to modify the calling thread, so run it on its own
   897  		// throwaway thread and do not unlock it when the goroutine exits.
   898  		runtime.LockOSThread()
   899  		defer close(skipc)
   900  
   901  		err := unix.Prctl(unix.PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)
   902  		if err != nil {
   903  			t.Logf("Prctl: %v, skipping test", err)
   904  			skip()
   905  		}
   906  
   907  		v, err := unix.PrctlRetInt(unix.PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0)
   908  		if err != nil {
   909  			t.Errorf("failed to perform prctl: %v", err)
   910  		}
   911  		if v != 1 {
   912  			t.Errorf("unexpected return from prctl; got %v, expected %v", v, 1)
   913  		}
   914  	}()
   915  
   916  	if <-skipc {
   917  		t.SkipNow()
   918  	}
   919  }
   920  
   921  func TestTimerfd(t *testing.T) {
   922  	var now unix.Timespec
   923  	if err := unix.ClockGettime(unix.CLOCK_REALTIME, &now); err != nil {
   924  		t.Fatalf("ClockGettime: %v", err)
   925  	}
   926  
   927  	tfd, err := unix.TimerfdCreate(unix.CLOCK_REALTIME, 0)
   928  	if err == unix.ENOSYS {
   929  		t.Skip("timerfd_create system call not implemented")
   930  	} else if err != nil {
   931  		t.Fatalf("TimerfdCreate: %v", err)
   932  	}
   933  	defer unix.Close(tfd)
   934  
   935  	var timeSpec unix.ItimerSpec
   936  	if err := unix.TimerfdGettime(tfd, &timeSpec); err != nil {
   937  		t.Fatalf("TimerfdGettime: %v", err)
   938  	}
   939  
   940  	if timeSpec.Value.Nsec != 0 || timeSpec.Value.Sec != 0 {
   941  		t.Fatalf("TimerfdGettime: timer is already set, but shouldn't be")
   942  	}
   943  
   944  	timeSpec = unix.ItimerSpec{
   945  		Interval: unix.NsecToTimespec(int64(time.Millisecond)),
   946  		Value:    now,
   947  	}
   948  
   949  	if err := unix.TimerfdSettime(tfd, unix.TFD_TIMER_ABSTIME, &timeSpec, nil); err != nil {
   950  		t.Fatalf("TimerfdSettime: %v", err)
   951  	}
   952  
   953  	const totalTicks = 10
   954  	const bufferLength = 8
   955  
   956  	buffer := make([]byte, bufferLength)
   957  
   958  	var count uint64 = 0
   959  	for count < totalTicks {
   960  		n, err := unix.Read(tfd, buffer)
   961  		if err != nil {
   962  			t.Fatalf("Timerfd: %v", err)
   963  		} else if n != bufferLength {
   964  			t.Fatalf("Timerfd: got %d bytes from timerfd, expected %d bytes", n, bufferLength)
   965  		}
   966  
   967  		count += *(*uint64)(unsafe.Pointer(&buffer))
   968  	}
   969  }
   970  
   971  func TestOpenat2(t *testing.T) {
   972  	how := &unix.OpenHow{
   973  		Flags: unix.O_RDONLY,
   974  	}
   975  	fd, err := unix.Openat2(unix.AT_FDCWD, ".", how)
   976  	if err != nil {
   977  		if err == unix.ENOSYS || err == unix.EPERM {
   978  			t.Skipf("openat2: %v (old kernel? need Linux >= 5.6)", err)
   979  		}
   980  		t.Fatalf("openat2: %v", err)
   981  	}
   982  	if err := unix.Close(fd); err != nil {
   983  		t.Fatalf("close: %v", err)
   984  	}
   985  
   986  	// prepare
   987  	subdir := filepath.Join(t.TempDir(), "dir")
   988  	if err := os.Mkdir(subdir, 0755); err != nil {
   989  		t.Fatal(err)
   990  	}
   991  	symlink := filepath.Join(subdir, "symlink")
   992  	if err := os.Symlink("../", symlink); err != nil {
   993  		t.Fatal(err)
   994  	}
   995  
   996  	dirfd, err := unix.Open(subdir, unix.O_RDONLY, 0)
   997  	if err != nil {
   998  		t.Fatalf("open(%q): %v", subdir, err)
   999  	}
  1000  	defer unix.Close(dirfd)
  1001  
  1002  	// openat2 with no extra flags -- should succeed
  1003  	fd, err = unix.Openat2(dirfd, "symlink", how)
  1004  	if err != nil {
  1005  		t.Errorf("Openat2 should succeed, got %v", err)
  1006  	}
  1007  	if err := unix.Close(fd); err != nil {
  1008  		t.Fatalf("close: %v", err)
  1009  	}
  1010  
  1011  	// open with RESOLVE_BENEATH, should result in EXDEV
  1012  	how.Resolve = unix.RESOLVE_BENEATH
  1013  	fd, err = unix.Openat2(dirfd, "symlink", how)
  1014  	if err == nil {
  1015  		if err := unix.Close(fd); err != nil {
  1016  			t.Fatalf("close: %v", err)
  1017  		}
  1018  	}
  1019  	if err != unix.EXDEV {
  1020  		t.Errorf("Openat2 should fail with EXDEV, got %v", err)
  1021  	}
  1022  }
  1023  
  1024  func TestIoctlFileDedupeRange(t *testing.T) {
  1025  	dir := t.TempDir()
  1026  	f1, err := os.Create(filepath.Join(dir, "f1"))
  1027  	if err != nil {
  1028  		t.Fatal(err)
  1029  	}
  1030  	defer f1.Close()
  1031  
  1032  	// Test deduplication with two blocks of zeros
  1033  	data := make([]byte, 4096)
  1034  
  1035  	for i := 0; i < 2; i += 1 {
  1036  		_, err = f1.Write(data)
  1037  		if err != nil {
  1038  			t.Fatal(err)
  1039  		}
  1040  	}
  1041  
  1042  	f2, err := os.Create(filepath.Join(dir, "f2"))
  1043  	if err != nil {
  1044  		t.Fatal(err)
  1045  	}
  1046  	defer f2.Close()
  1047  
  1048  	for i := 0; i < 2; i += 1 {
  1049  		// Make the 2nd block different
  1050  		if i == 1 {
  1051  			data[1] = 1
  1052  		}
  1053  
  1054  		_, err = f2.Write(data)
  1055  		if err != nil {
  1056  			t.Fatal(err)
  1057  		}
  1058  	}
  1059  
  1060  	dedupe := unix.FileDedupeRange{
  1061  		Src_offset: uint64(0),
  1062  		Src_length: uint64(4096),
  1063  		Info: []unix.FileDedupeRangeInfo{
  1064  			unix.FileDedupeRangeInfo{
  1065  				Dest_fd:     int64(f2.Fd()),
  1066  				Dest_offset: uint64(0),
  1067  			},
  1068  			unix.FileDedupeRangeInfo{
  1069  				Dest_fd:     int64(f2.Fd()),
  1070  				Dest_offset: uint64(4096),
  1071  			},
  1072  		}}
  1073  
  1074  	err = unix.IoctlFileDedupeRange(int(f1.Fd()), &dedupe)
  1075  	if err == unix.EOPNOTSUPP || err == unix.EINVAL || err == unix.ENOTTY {
  1076  		t.Skip("deduplication not supported on this filesystem")
  1077  	} else if err != nil {
  1078  		t.Fatal(err)
  1079  	}
  1080  
  1081  	// The first Info should be equal
  1082  	if dedupe.Info[0].Status < 0 {
  1083  		errno := unix.Errno(-dedupe.Info[0].Status)
  1084  		if errno == unix.EINVAL {
  1085  			t.Skip("deduplication not supported on this filesystem")
  1086  		}
  1087  		t.Errorf("Unexpected error in FileDedupeRange: %s", unix.ErrnoName(errno))
  1088  	} else if dedupe.Info[0].Status == unix.FILE_DEDUPE_RANGE_DIFFERS {
  1089  		t.Errorf("Unexpected different bytes in FileDedupeRange")
  1090  	}
  1091  	if dedupe.Info[0].Bytes_deduped != 4096 {
  1092  		t.Errorf("Unexpected amount of bytes deduped %v != %v",
  1093  			dedupe.Info[0].Bytes_deduped, 4096)
  1094  	}
  1095  
  1096  	// The second Info should be different
  1097  	if dedupe.Info[1].Status < 0 {
  1098  		errno := unix.Errno(-dedupe.Info[1].Status)
  1099  		if errno == unix.EINVAL {
  1100  			t.Skip("deduplication not supported on this filesystem")
  1101  		}
  1102  		t.Errorf("Unexpected error in FileDedupeRange: %s", unix.ErrnoName(errno))
  1103  	} else if dedupe.Info[1].Status == unix.FILE_DEDUPE_RANGE_SAME {
  1104  		t.Errorf("Unexpected equal bytes in FileDedupeRange")
  1105  	}
  1106  	if dedupe.Info[1].Bytes_deduped != 0 {
  1107  		t.Errorf("Unexpected amount of bytes deduped %v != %v",
  1108  			dedupe.Info[1].Bytes_deduped, 0)
  1109  	}
  1110  }
  1111  
  1112  // TestPwritevOffsets tests golang.org/issues/57291 where
  1113  // offs2lohi was shifting by the size of long in bytes, not bits.
  1114  func TestPwritevOffsets(t *testing.T) {
  1115  	path := filepath.Join(t.TempDir(), "x.txt")
  1116  
  1117  	f, err := os.Create(path)
  1118  	if err != nil {
  1119  		t.Fatal(err)
  1120  	}
  1121  	t.Cleanup(func() { f.Close() })
  1122  
  1123  	const (
  1124  		off = 20
  1125  	)
  1126  	b := [][]byte{{byte(0)}}
  1127  	n, err := unix.Pwritev(int(f.Fd()), b, off)
  1128  	if err != nil {
  1129  		t.Fatal(err)
  1130  	}
  1131  	if n != len(b) {
  1132  		t.Fatalf("expected to write %d, wrote %d", len(b), n)
  1133  	}
  1134  
  1135  	info, err := f.Stat()
  1136  	if err != nil {
  1137  		t.Fatal(err)
  1138  	}
  1139  	want := off + int64(len(b))
  1140  	if info.Size() != want {
  1141  		t.Fatalf("expected size to be %d, got %d", want, info.Size())
  1142  	}
  1143  }
  1144  
  1145  func TestReadvAllocate(t *testing.T) {
  1146  	f, err := os.Create(filepath.Join(t.TempDir(), "test"))
  1147  	if err != nil {
  1148  		t.Fatal(err)
  1149  	}
  1150  	t.Cleanup(func() { f.Close() })
  1151  
  1152  	test := func(name string, fn func(fd int)) {
  1153  		n := int(testing.AllocsPerRun(100, func() {
  1154  			fn(int(f.Fd()))
  1155  		}))
  1156  		if n != 0 {
  1157  			t.Errorf("%q got %d allocations, want 0", name, n)
  1158  		}
  1159  	}
  1160  
  1161  	iovs := make([][]byte, 8)
  1162  	for i := range iovs {
  1163  		iovs[i] = []byte{'A'}
  1164  	}
  1165  
  1166  	test("Writev", func(fd int) {
  1167  		unix.Writev(fd, iovs)
  1168  	})
  1169  	test("Pwritev", func(fd int) {
  1170  		unix.Pwritev(fd, iovs, 0)
  1171  	})
  1172  	test("Pwritev2", func(fd int) {
  1173  		unix.Pwritev2(fd, iovs, 0, 0)
  1174  	})
  1175  	test("Readv", func(fd int) {
  1176  		unix.Readv(fd, iovs)
  1177  	})
  1178  	test("Preadv", func(fd int) {
  1179  		unix.Preadv(fd, iovs, 0)
  1180  	})
  1181  	test("Preadv2", func(fd int) {
  1182  		unix.Preadv2(fd, iovs, 0, 0)
  1183  	})
  1184  }
  1185  
  1186  func TestSockaddrALG(t *testing.T) {
  1187  	// Open a socket to perform SHA1 hashing.
  1188  	fd, err := unix.Socket(unix.AF_ALG, unix.SOCK_SEQPACKET, 0)
  1189  	if err != nil {
  1190  		t.Skip("socket(AF_ALG):", err)
  1191  	}
  1192  	defer unix.Close(fd)
  1193  	addr := &unix.SockaddrALG{Type: "hash", Name: "sha1"}
  1194  	if err := unix.Bind(fd, addr); err != nil {
  1195  		t.Fatal("bind:", err)
  1196  	}
  1197  	// Need to call accept(2) with the second and third arguments as 0,
  1198  	// which is not possible via unix.Accept, thus the use of unix.Syscall.
  1199  	hashfd, _, errno := unix.Syscall6(unix.SYS_ACCEPT4, uintptr(fd), 0, 0, 0, 0, 0)
  1200  	if errno != 0 {
  1201  		t.Fatal("accept:", errno)
  1202  	}
  1203  
  1204  	hash := os.NewFile(hashfd, "sha1")
  1205  	defer hash.Close()
  1206  
  1207  	// Hash an input string and read the results.
  1208  	const (
  1209  		input = "Hello, world."
  1210  		exp   = "2ae01472317d1935a84797ec1983ae243fc6aa28"
  1211  	)
  1212  	if _, err := hash.WriteString(input); err != nil {
  1213  		t.Fatal(err)
  1214  	}
  1215  	b := make([]byte, 20)
  1216  	if _, err := hash.Read(b); err != nil {
  1217  		t.Fatal(err)
  1218  	}
  1219  	got := hex.EncodeToString(b)
  1220  	if got != exp {
  1221  		t.Fatalf("got: %q, want: %q", got, exp)
  1222  	}
  1223  }
  1224
View as plain text