if fd.fakeNetFD != nil {
		return fd.fakeNetFD.closeRead()
	}
	return os.NewSyscallError("closeRead", syscall.ENOTSUP)
}

func (fd *netFD) closeWrite() error {
	if fd.fakeNetFD != nil {
		return fd.fakeNetFD.closeWrite()
	}
	return os.NewSyscallError("closeRead", syscall.ENOTSUP)

	return ignoringEINTR(func() error {
		_, err := unix.Fcntl(fd.Sysfd, syscall.F_FULLFSYNC, 0)

		// There are scenarios such as SMB mounts where fcntl will fail
		// with ENOTSUP. In those cases fallback to fsync.
		// See #64215
		if err != nil && errors.Is(err, syscall.ENOTSUP) {
			err = syscall.Fsync(fd.Sysfd)
		}
		return err
	})

	ENOSPC          Errno = 51
	ENOSYS          Errno = 52
	ENOTCONN        Errno = 53
	ENOTDIR         Errno = 54
	ENOTEMPTY       Errno = 55
	ENOTRECOVERABLE Errno = 56
	ENOTSOCK        Errno = 57
	ENOTSUP         Errno = 58
	ENOTTY          Errno = 59
	ENXIO           Errno = 60
	EOVERFLOW       Errno = 61
	EOWNERDEAD      Errno = 62
	EPERM           Errno = 63
	EPIPE           Errno = 64
	EPROTO          Errno = 65

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build ios

package unix

func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
	return ENOTSUP

// for a regression vs. the fix for #43149.
func TestAllThreadsSyscallSignals(t *testing.T) {
	if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, prSetKeepCaps, 0, 0); err == syscall.ENOTSUP {
		t.Skip("AllThreadsSyscall disabled with cgo")
	}

	sig := make(chan os.Signal, 1)
	Notify(sig, os.Interrupt)

	for i := 0; i <= 100; i++ {

		}
	}
	if err != nil {
		// Some file systems do not support fallocate. We ignore that error as linking
		// can still take place, but you might SIGBUS when you write to the mmapped
		// area.
		if err != syscall.ENOTSUP && err != syscall.EPERM && err != errNoFallocate {
			return err
		}
	}
	err = out.f.Truncate(int64(filesize))
	if err != nil {
		Exitf("resize output file failed: %v", err)
	}

	if raddr != nil && ctrlCtxFn != nil {
		return nil, os.NewSyscallError("socket", syscall.ENOTSUP)
	}
	switch sotype {
	case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET, syscall.SOCK_DGRAM:
	default:
		return nil, os.NewSyscallError("socket", syscall.ENOTSUP)
	}

	fd := &netFD{
		family: family,
		sotype: sotype,
		net:    net,
	}
	fd.fakeNetFD = newFakeNetFD(fd)

	ENOLINK
	ENOMEDIUM
	ENOMEM
	ENOMSG
	ENONET
	ENOPKG
	ENOPROTOOPT
	ENOSPC
	ENOSR
	ENOSTR
	ENOSYS
	ENOTBLK
	ENOTCONN
	ENOTEMPTY
	ENOTNAM
	ENOTRECOVERABLE
	ENOTSOCK
	ENOTSUP
	ENOTTY
	ENOTUNIQ
	ENXIO
	EOPNOTSUPP
	EOVERFLOW
	EOWNERDEAD
	EPERM
	EPFNOSUPPORT
	EPIPE
	EPROTO
	EPROTONOSUPPORT
	EPROTOTYPE
	ERANGE
	EREMCHG
	EREMOTE
	EREMOTEIO

	"ECONNREFUSED":    ECONNREFUSED,
	"EHOSTDOWN":       EHOSTDOWN,
	"EHOSTUNREACH":    EHOSTUNREACH,
	"EALREADY":        EALREADY,
	"EINPROGRESS":     EINPROGRESS,
	"ESTALE":          ESTALE,
	"ENOTSUP":         ENOTSUP,
	"ENOMEDIUM":       ENOMEDIUM,
	"ECANCELED":       ECANCELED,
	"ELBIN":           ELBIN,
	"EFTYPE":          EFTYPE,
	"ENMFILE":         ENMFILE,
	"EPROCLIM":        EPROCLIM,

// POSIX semantics for security state changes.
func TestAllThreadsSyscall(t *testing.T) {
	if _, _, err := syscall.AllThreadsSyscall(syscall.SYS_PRCTL, PR_SET_KEEPCAPS, 0, 0); err == syscall.ENOTSUP {
		t.Skip("AllThreadsSyscall disabled with cgo")
	}

	fns := []struct {
		label string
		fn    func(uintptr) error
	}{
		{
			label: "prctl<3-args>",
			fn: func(v uintptr) error {