[chore] remove vendor

1 files changed, 0 insertions, 3213 deletions

diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
deleted file mode 100644
index 7bf5c04bb..000000000
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ /dev/null
@@ -1,3213 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build zos && s390x
-
-// Many of the following syscalls are not available on all versions of z/OS.
-// Some missing calls have legacy implementations/simulations but others
-// will be missing completely. To achieve consistent failing behaviour on
-// legacy systems, we first test the function pointer via a safeloading
-// mechanism to see if the function exists on a given system. Then execution
-// is branched to either continue the function call, or return an error.
-
-package unix
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"reflect"
-	"regexp"
-	"runtime"
-	"sort"
-	"strings"
-	"sync"
-	"syscall"
-	"unsafe"
-)
-
-//go:noescape
-func initZosLibVec()
-
-//go:noescape
-func GetZosLibVec() uintptr
-
-func init() {
-	initZosLibVec()
-	r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACE\x00"))[0])))
-	if r0 != 0 {
-		n, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0)
-		ZosTraceLevel = int(n)
-		r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACEFD\x00"))[0])))
-		if r0 != 0 {
-			fd, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0)
-			f := os.NewFile(fd, "zostracefile")
-			if f != nil {
-				ZosTracefile = f
-			}
-		}
-
-	}
-}
-
-//go:noescape
-func CallLeFuncWithErr(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno)
-
-//go:noescape
-func CallLeFuncWithPtrReturn(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno)
-
-// -------------------------------
-// pointer validity test
-// good pointer returns 0
-// bad pointer returns 1
-//
-//go:nosplit
-func ptrtest(uintptr) uint64
-
-// Load memory at ptr location with error handling if the location is invalid
-//
-//go:noescape
-func safeload(ptr uintptr) (value uintptr, error uintptr)
-
-const (
-	entrypointLocationOffset = 8 // From function descriptor
-
-	xplinkEyecatcher   = 0x00c300c500c500f1 // ".C.E.E.1"
-	eyecatcherOffset   = 16                 // From function entrypoint (negative)
-	ppa1LocationOffset = 8                  // From function entrypoint (negative)
-
-	nameLenOffset = 0x14 // From PPA1 start
-	nameOffset    = 0x16 // From PPA1 start
-)
-
-func getPpaOffset(funcptr uintptr) int64 {
-	entrypoint, err := safeload(funcptr + entrypointLocationOffset)
-	if err != 0 {
-		return -1
-	}
-
-	// XPLink functions have ".C.E.E.1" as the first 8 bytes (EBCDIC)
-	val, err := safeload(entrypoint - eyecatcherOffset)
-	if err != 0 {
-		return -1
-	}
-	if val != xplinkEyecatcher {
-		return -1
-	}
-
-	ppaoff, err := safeload(entrypoint - ppa1LocationOffset)
-	if err != 0 {
-		return -1
-	}
-
-	ppaoff >>= 32
-	return int64(ppaoff)
-}
-
-//-------------------------------
-// function descriptor pointer validity test
-// good pointer returns 0
-// bad pointer returns 1
-
-// TODO: currently mksyscall_zos_s390x.go generate empty string for funcName
-// have correct funcName pass to the funcptrtest function
-func funcptrtest(funcptr uintptr, funcName string) uint64 {
-	entrypoint, err := safeload(funcptr + entrypointLocationOffset)
-	if err != 0 {
-		return 1
-	}
-
-	ppaoff := getPpaOffset(funcptr)
-	if ppaoff == -1 {
-		return 1
-	}
-
-	// PPA1 offset value is from the start of the entire function block, not the entrypoint
-	ppa1 := (entrypoint - eyecatcherOffset) + uintptr(ppaoff)
-
-	nameLen, err := safeload(ppa1 + nameLenOffset)
-	if err != 0 {
-		return 1
-	}
-
-	nameLen >>= 48
-	if nameLen > 128 {
-		return 1
-	}
-
-	// no function name input to argument end here
-	if funcName == "" {
-		return 0
-	}
-
-	var funcname [128]byte
-	for i := 0; i < int(nameLen); i += 8 {
-		v, err := safeload(ppa1 + nameOffset + uintptr(i))
-		if err != 0 {
-			return 1
-		}
-		funcname[i] = byte(v >> 56)
-		funcname[i+1] = byte(v >> 48)
-		funcname[i+2] = byte(v >> 40)
-		funcname[i+3] = byte(v >> 32)
-		funcname[i+4] = byte(v >> 24)
-		funcname[i+5] = byte(v >> 16)
-		funcname[i+6] = byte(v >> 8)
-		funcname[i+7] = byte(v)
-	}
-
-	runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l
-		[]uintptr{uintptr(unsafe.Pointer(&funcname[0])), nameLen})
-
-	name := string(funcname[:nameLen])
-	if name != funcName {
-		return 1
-	}
-
-	return 0
-}
-
-// For detection of capabilities on a system.
-// Is function descriptor f a valid function?
-func isValidLeFunc(f uintptr) error {
-	ret := funcptrtest(f, "")
-	if ret != 0 {
-		return fmt.Errorf("Bad pointer, not an LE function ")
-	}
-	return nil
-}
-
-// Retrieve function name from descriptor
-func getLeFuncName(f uintptr) (string, error) {
-	// assume it has been checked, only check ppa1 validity here
-	entry := ((*[2]uintptr)(unsafe.Pointer(f)))[1]
-	preamp := ((*[4]uint32)(unsafe.Pointer(entry - eyecatcherOffset)))
-
-	offsetPpa1 := preamp[2]
-	if offsetPpa1 > 0x0ffff {
-		return "", fmt.Errorf("PPA1 offset seems too big 0x%x\n", offsetPpa1)
-	}
-
-	ppa1 := uintptr(unsafe.Pointer(preamp)) + uintptr(offsetPpa1)
-	res := ptrtest(ppa1)
-	if res != 0 {
-		return "", fmt.Errorf("PPA1 address not valid")
-	}
-
-	size := *(*uint16)(unsafe.Pointer(ppa1 + nameLenOffset))
-	if size > 128 {
-		return "", fmt.Errorf("Function name seems too long, length=%d\n", size)
-	}
-
-	var name [128]byte
-	funcname := (*[128]byte)(unsafe.Pointer(ppa1 + nameOffset))
-	copy(name[0:size], funcname[0:size])
-
-	runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l
-		[]uintptr{uintptr(unsafe.Pointer(&name[0])), uintptr(size)})
-
-	return string(name[:size]), nil
-}
-
-// Check z/OS version
-func zosLeVersion() (version, release uint32) {
-	p1 := (*(*uintptr)(unsafe.Pointer(uintptr(1208)))) >> 32
-	p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 88)))
-	p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 8)))
-	p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 984)))
-	vrm := *(*uint32)(unsafe.Pointer(p1 + 80))
-	version = (vrm & 0x00ff0000) >> 16
-	release = (vrm & 0x0000ff00) >> 8
-	return
-}
-
-// returns a zos C FILE * for stdio fd 0, 1, 2
-func ZosStdioFilep(fd int32) uintptr {
-	return uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(uint64(*(*uint32)(unsafe.Pointer(uintptr(1208)))) + 80))) + uint64((fd+2)<<3))))))))
-}
-
-func copyStat(stat *Stat_t, statLE *Stat_LE_t) {
-	stat.Dev = uint64(statLE.Dev)
-	stat.Ino = uint64(statLE.Ino)
-	stat.Nlink = uint64(statLE.Nlink)
-	stat.Mode = uint32(statLE.Mode)
-	stat.Uid = uint32(statLE.Uid)
-	stat.Gid = uint32(statLE.Gid)
-	stat.Rdev = uint64(statLE.Rdev)
-	stat.Size = statLE.Size
-	stat.Atim.Sec = int64(statLE.Atim)
-	stat.Atim.Nsec = 0 //zos doesn't return nanoseconds
-	stat.Mtim.Sec = int64(statLE.Mtim)
-	stat.Mtim.Nsec = 0 //zos doesn't return nanoseconds
-	stat.Ctim.Sec = int64(statLE.Ctim)
-	stat.Ctim.Nsec = 0 //zos doesn't return nanoseconds
-	stat.Blksize = int64(statLE.Blksize)
-	stat.Blocks = statLE.Blocks
-}
-
-func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
-func svcLoad(name *byte) unsafe.Pointer
-func svcUnload(name *byte, fnptr unsafe.Pointer) int64
-
-func (d *Dirent) NameString() string {
-	if d == nil {
-		return ""
-	}
-	s := string(d.Name[:])
-	idx := strings.IndexByte(s, 0)
-	if idx == -1 {
-		return s
-	} else {
-		return s[:idx]
-	}
-}
-
-func DecodeData(dest []byte, sz int, val uint64) {
-	for i := 0; i < sz; i++ {
-		dest[sz-1-i] = byte((val >> (uint64(i * 8))) & 0xff)
-	}
-}
-
-func EncodeData(data []byte) uint64 {
-	var value uint64
-	sz := len(data)
-	for i := 0; i < sz; i++ {
-		value |= uint64(data[i]) << uint64(((sz - i - 1) * 8))
-	}
-	return value
-}
-
-func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
-	if sa.Port < 0 || sa.Port > 0xFFFF {
-		return nil, 0, EINVAL
-	}
-	sa.raw.Len = SizeofSockaddrInet4
-	sa.raw.Family = AF_INET
-	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
-	p[0] = byte(sa.Port >> 8)
-	p[1] = byte(sa.Port)
-	for i := 0; i < len(sa.Addr); i++ {
-		sa.raw.Addr[i] = sa.Addr[i]
-	}
-	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
-}
-
-func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
-	if sa.Port < 0 || sa.Port > 0xFFFF {
-		return nil, 0, EINVAL
-	}
-	sa.raw.Len = SizeofSockaddrInet6
-	sa.raw.Family = AF_INET6
-	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
-	p[0] = byte(sa.Port >> 8)
-	p[1] = byte(sa.Port)
-	sa.raw.Scope_id = sa.ZoneId
-	for i := 0; i < len(sa.Addr); i++ {
-		sa.raw.Addr[i] = sa.Addr[i]
-	}
-	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
-}
-
-func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
-	name := sa.Name
-	n := len(name)
-	if n >= len(sa.raw.Path) || n == 0 {
-		return nil, 0, EINVAL
-	}
-	sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
-	sa.raw.Family = AF_UNIX
-	for i := 0; i < n; i++ {
-		sa.raw.Path[i] = int8(name[i])
-	}
-	return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
-}
-
-func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) {
-	// TODO(neeilan): Implement use of first param (fd)
-	switch rsa.Addr.Family {
-	case AF_UNIX:
-		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
-		sa := new(SockaddrUnix)
-		// For z/OS, only replace NUL with @ when the
-		// length is not zero.
-		if pp.Len != 0 && pp.Path[0] == 0 {
-			// "Abstract" Unix domain socket.
-			// Rewrite leading NUL as @ for textual display.
-			// (This is the standard convention.)
-			// Not friendly to overwrite in place,
-			// but the callers below don't care.
-			pp.Path[0] = '@'
-		}
-
-		// Assume path ends at NUL.
-		//
-		// For z/OS, the length of the name is a field
-		// in the structure. To be on the safe side, we
-		// will still scan the name for a NUL but only
-		// to the length provided in the structure.
-		//
-		// This is not technically the Linux semantics for
-		// abstract Unix domain sockets--they are supposed
-		// to be uninterpreted fixed-size binary blobs--but
-		// everyone uses this convention.
-		n := 0
-		for n < int(pp.Len) && pp.Path[n] != 0 {
-			n++
-		}
-		sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
-		return sa, nil
-
-	case AF_INET:
-		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
-		sa := new(SockaddrInet4)
-		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
-		sa.Port = int(p[0])<<8 + int(p[1])
-		for i := 0; i < len(sa.Addr); i++ {
-			sa.Addr[i] = pp.Addr[i]
-		}
-		return sa, nil
-
-	case AF_INET6:
-		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
-		sa := new(SockaddrInet6)
-		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
-		sa.Port = int(p[0])<<8 + int(p[1])
-		sa.ZoneId = pp.Scope_id
-		for i := 0; i < len(sa.Addr); i++ {
-			sa.Addr[i] = pp.Addr[i]
-		}
-		return sa, nil
-	}
-	return nil, EAFNOSUPPORT
-}
-
-func Accept(fd int) (nfd int, sa Sockaddr, err error) {
-	var rsa RawSockaddrAny
-	var len _Socklen = SizeofSockaddrAny
-	nfd, err = accept(fd, &rsa, &len)
-	if err != nil {
-		return
-	}
-	// TODO(neeilan): Remove 0 in call
-	sa, err = anyToSockaddr(0, &rsa)
-	if err != nil {
-		Close(nfd)
-		nfd = 0
-	}
-	return
-}
-
-func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
-	var rsa RawSockaddrAny
-	var len _Socklen = SizeofSockaddrAny
-	nfd, err = accept4(fd, &rsa, &len, flags)
-	if err != nil {
-		return
-	}
-	if len > SizeofSockaddrAny {
-		panic("RawSockaddrAny too small")
-	}
-	// TODO(neeilan): Remove 0 in call
-	sa, err = anyToSockaddr(0, &rsa)
-	if err != nil {
-		Close(nfd)
-		nfd = 0
-	}
-	return
-}
-
-func Ctermid() (tty string, err error) {
-	var termdev [1025]byte
-	runtime.EnterSyscall()
-	r0, err2, err1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___CTERMID_A<<4, uintptr(unsafe.Pointer(&termdev[0])))
-	runtime.ExitSyscall()
-	if r0 == 0 {
-		return "", fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2)
-	}
-	s := string(termdev[:])
-	idx := strings.Index(s, string(rune(0)))
-	if idx == -1 {
-		tty = s
-	} else {
-		tty = s[:idx]
-	}
-	return
-}
-
-func (iov *Iovec) SetLen(length int) {
-	iov.Len = uint64(length)
-}
-
-func (msghdr *Msghdr) SetControllen(length int) {
-	msghdr.Controllen = int32(length)
-}
-
-func (cmsg *Cmsghdr) SetLen(length int) {
-	cmsg.Len = int32(length)
-}
-
-//sys   fcntl(fd int, cmd int, arg int) (val int, err error)
-//sys   Flistxattr(fd int, dest []byte) (sz int, err error) = SYS___FLISTXATTR_A
-//sys   Fremovexattr(fd int, attr string) (err error) = SYS___FREMOVEXATTR_A
-//sys	read(fd int, p []byte) (n int, err error)
-//sys	write(fd int, p []byte) (n int, err error)
-
-//sys   Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) = SYS___FGETXATTR_A
-//sys   Fsetxattr(fd int, attr string, data []byte, flag int) (err error) = SYS___FSETXATTR_A
-
-//sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = SYS___ACCEPT_A
-//sys	accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) = SYS___ACCEPT4_A
-//sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___BIND_A
-//sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___CONNECT_A
-//sysnb	getgroups(n int, list *_Gid_t) (nn int, err error)
-//sysnb	setgroups(n int, list *_Gid_t) (err error)
-//sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
-//sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
-//sysnb	socket(domain int, typ int, proto int) (fd int, err error)
-//sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
-//sysnb	getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETPEERNAME_A
-//sysnb	getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETSOCKNAME_A
-//sys   Removexattr(path string, attr string) (err error) = SYS___REMOVEXATTR_A
-//sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = SYS___RECVFROM_A
-//sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = SYS___SENDTO_A
-//sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___RECVMSG_A
-//sys	sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___SENDMSG_A
-//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) = SYS_MMAP
-//sys   munmap(addr uintptr, length uintptr) (err error) = SYS_MUNMAP
-//sys   ioctl(fd int, req int, arg uintptr) (err error) = SYS_IOCTL
-//sys   ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) = SYS_IOCTL
-//sys	shmat(id int, addr uintptr, flag int) (ret uintptr, err error) = SYS_SHMAT
-//sys	shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) = SYS_SHMCTL64
-//sys	shmdt(addr uintptr) (err error) = SYS_SHMDT
-//sys	shmget(key int, size int, flag int) (id int, err error) = SYS_SHMGET
-
-//sys   Access(path string, mode uint32) (err error) = SYS___ACCESS_A
-//sys   Chdir(path string) (err error) = SYS___CHDIR_A
-//sys	Chown(path string, uid int, gid int) (err error) = SYS___CHOWN_A
-//sys	Chmod(path string, mode uint32) (err error) = SYS___CHMOD_A
-//sys   Creat(path string, mode uint32) (fd int, err error) = SYS___CREAT_A
-//sys	Dup(oldfd int) (fd int, err error)
-//sys	Dup2(oldfd int, newfd int) (err error)
-//sys	Dup3(oldfd int, newfd int, flags int) (err error) = SYS_DUP3
-//sys	Dirfd(dirp uintptr) (fd int, err error) = SYS_DIRFD
-//sys	EpollCreate(size int) (fd int, err error) = SYS_EPOLL_CREATE
-//sys	EpollCreate1(flags int) (fd int, err error) = SYS_EPOLL_CREATE1
-//sys	EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) = SYS_EPOLL_CTL
-//sys	EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) = SYS_EPOLL_PWAIT
-//sys	EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_WAIT
-//sys	Errno2() (er2 int) = SYS___ERRNO2
-//sys	Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD
-//sys	Exit(code int)
-//sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FACCESSAT_A
-
-func Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) {
-	return Faccessat(dirfd, path, mode, flags)
-}
-
-//sys	Fchdir(fd int) (err error)
-//sys	Fchmod(fd int, mode uint32) (err error)
-//sys	Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FCHMODAT_A
-//sys	Fchown(fd int, uid int, gid int) (err error)
-//sys	Fchownat(fd int, path string, uid int, gid int, flags int) (err error) = SYS___FCHOWNAT_A
-//sys	FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) = SYS_FCNTL
-//sys	Fdatasync(fd int) (err error) = SYS_FDATASYNC
-//sys	fstat(fd int, stat *Stat_LE_t) (err error)
-//sys	fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) = SYS___FSTATAT_A
-
-func Fstat(fd int, stat *Stat_t) (err error) {
-	var statLE Stat_LE_t
-	err = fstat(fd, &statLE)
-	copyStat(stat, &statLE)
-	return
-}
-
-func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) {
-	var statLE Stat_LE_t
-	err = fstatat(dirfd, path, &statLE, flags)
-	copyStat(stat, &statLE)
-	return
-}
-
-func impl_Getxattr(path string, attr string, dest []byte) (sz int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	var _p2 unsafe.Pointer
-	if len(dest) > 0 {
-		_p2 = unsafe.Pointer(&dest[0])
-	} else {
-		_p2 = unsafe.Pointer(&_zero)
-	}
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)))
-	sz = int(r0)
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_GetxattrAddr() *(func(path string, attr string, dest []byte) (sz int, err error))
-
-var Getxattr = enter_Getxattr
-
-func enter_Getxattr(path string, attr string, dest []byte) (sz int, err error) {
-	funcref := get_GetxattrAddr()
-	if validGetxattr() {
-		*funcref = impl_Getxattr
-	} else {
-		*funcref = error_Getxattr
-	}
-	return (*funcref)(path, attr, dest)
-}
-
-func error_Getxattr(path string, attr string, dest []byte) (sz int, err error) {
-	return -1, ENOSYS
-}
-
-func validGetxattr() bool {
-	if funcptrtest(GetZosLibVec()+SYS___GETXATTR_A<<4, "") == 0 {
-		if name, err := getLeFuncName(GetZosLibVec() + SYS___GETXATTR_A<<4); err == nil {
-			return name == "__getxattr_a"
-		}
-	}
-	return false
-}
-
-//sys   Lgetxattr(link string, attr string, dest []byte) (sz int, err error) = SYS___LGETXATTR_A
-//sys   Lsetxattr(path string, attr string, data []byte, flags int) (err error) = SYS___LSETXATTR_A
-
-func impl_Setxattr(path string, attr string, data []byte, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(attr)
-	if err != nil {
-		return
-	}
-	var _p2 unsafe.Pointer
-	if len(data) > 0 {
-		_p2 = unsafe.Pointer(&data[0])
-	} else {
-		_p2 = unsafe.Pointer(&_zero)
-	}
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags))
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_SetxattrAddr() *(func(path string, attr string, data []byte, flags int) (err error))
-
-var Setxattr = enter_Setxattr
-
-func enter_Setxattr(path string, attr string, data []byte, flags int) (err error) {
-	funcref := get_SetxattrAddr()
-	if validSetxattr() {
-		*funcref = impl_Setxattr
-	} else {
-		*funcref = error_Setxattr
-	}
-	return (*funcref)(path, attr, data, flags)
-}
-
-func error_Setxattr(path string, attr string, data []byte, flags int) (err error) {
-	return ENOSYS
-}
-
-func validSetxattr() bool {
-	if funcptrtest(GetZosLibVec()+SYS___SETXATTR_A<<4, "") == 0 {
-		if name, err := getLeFuncName(GetZosLibVec() + SYS___SETXATTR_A<<4); err == nil {
-			return name == "__setxattr_a"
-		}
-	}
-	return false
-}
-
-//sys	Fstatfs(fd int, buf *Statfs_t) (err error) = SYS_FSTATFS
-//sys	Fstatvfs(fd int, stat *Statvfs_t) (err error) = SYS_FSTATVFS
-//sys	Fsync(fd int) (err error)
-//sys	Futimes(fd int, tv []Timeval) (err error) = SYS_FUTIMES
-//sys	Futimesat(dirfd int, path string, tv []Timeval) (err error) = SYS___FUTIMESAT_A
-//sys	Ftruncate(fd int, length int64) (err error)
-//sys	Getrandom(buf []byte, flags int) (n int, err error) = SYS_GETRANDOM
-//sys	InotifyInit() (fd int, err error) = SYS_INOTIFY_INIT
-//sys	InotifyInit1(flags int) (fd int, err error) = SYS_INOTIFY_INIT1
-//sys	InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) = SYS___INOTIFY_ADD_WATCH_A
-//sys	InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) = SYS_INOTIFY_RM_WATCH
-//sys   Listxattr(path string, dest []byte) (sz int, err error) = SYS___LISTXATTR_A
-//sys   Llistxattr(path string, dest []byte) (sz int, err error) = SYS___LLISTXATTR_A
-//sys   Lremovexattr(path string, attr string) (err error) = SYS___LREMOVEXATTR_A
-//sys	Lutimes(path string, tv []Timeval) (err error) = SYS___LUTIMES_A
-//sys   Mprotect(b []byte, prot int) (err error) = SYS_MPROTECT
-//sys   Msync(b []byte, flags int) (err error) = SYS_MSYNC
-//sys   Console2(cmsg *ConsMsg2, modstr *byte, concmd *uint32) (err error) = SYS___CONSOLE2
-
-// Pipe2 begin
-
-//go:nosplit
-func getPipe2Addr() *(func([]int, int) error)
-
-var Pipe2 = pipe2Enter
-
-func pipe2Enter(p []int, flags int) (err error) {
-	if funcptrtest(GetZosLibVec()+SYS_PIPE2<<4, "") == 0 {
-		*getPipe2Addr() = pipe2Impl
-	} else {
-		*getPipe2Addr() = pipe2Error
-	}
-	return (*getPipe2Addr())(p, flags)
-}
-
-func pipe2Impl(p []int, flags int) (err error) {
-	var pp [2]_C_int
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PIPE2<<4, uintptr(unsafe.Pointer(&pp[0])), uintptr(flags))
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	} else {
-		p[0] = int(pp[0])
-		p[1] = int(pp[1])
-	}
-	return
-}
-func pipe2Error(p []int, flags int) (err error) {
-	return fmt.Errorf("Pipe2 is not available on this system")
-}
-
-// Pipe2 end
-
-//sys   Poll(fds []PollFd, timeout int) (n int, err error) = SYS_POLL
-
-func Readdir(dir uintptr) (dirent *Dirent, err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READDIR_A<<4, uintptr(dir))
-	runtime.ExitSyscall()
-	dirent = (*Dirent)(unsafe.Pointer(r0))
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//sys	Readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) = SYS___READDIR_R_A
-//sys	Statfs(path string, buf *Statfs_t) (err error) = SYS___STATFS_A
-//sys	Syncfs(fd int) (err error) = SYS_SYNCFS
-//sys   Times(tms *Tms) (ticks uintptr, err error) = SYS_TIMES
-//sys   W_Getmntent(buff *byte, size int) (lastsys int, err error) = SYS_W_GETMNTENT
-//sys   W_Getmntent_A(buff *byte, size int) (lastsys int, err error) = SYS___W_GETMNTENT_A
-
-//sys   mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A
-//sys   unmount_LE(filesystem string, mtm int) (err error) = SYS___UMOUNT_A
-//sys   Chroot(path string) (err error) = SYS___CHROOT_A
-//sys   Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) = SYS_SELECT
-//sysnb Uname(buf *Utsname) (err error) = SYS_____OSNAME_A
-//sys   Unshare(flags int) (err error) = SYS_UNSHARE
-
-func Ptsname(fd int) (name string, err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___PTSNAME_A<<4, uintptr(fd))
-	runtime.ExitSyscall()
-	if r0 == 0 {
-		err = errnoErr2(e1, e2)
-	} else {
-		name = u2s(unsafe.Pointer(r0))
-	}
-	return
-}
-
-func u2s(cstr unsafe.Pointer) string {
-	str := (*[1024]uint8)(cstr)
-	i := 0
-	for str[i] != 0 {
-		i++
-	}
-	return string(str[:i])
-}
-
-func Close(fd int) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd))
-	runtime.ExitSyscall()
-	for i := 0; e1 == EAGAIN && i < 10; i++ {
-		runtime.EnterSyscall()
-		CallLeFuncWithErr(GetZosLibVec()+SYS_USLEEP<<4, uintptr(10))
-		runtime.ExitSyscall()
-		runtime.EnterSyscall()
-		r0, e2, e1 = CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd))
-		runtime.ExitSyscall()
-	}
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-// Dummy function: there are no semantics for Madvise on z/OS
-func Madvise(b []byte, advice int) (err error) {
-	return
-}
-
-func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
-	return mapper.Mmap(fd, offset, length, prot, flags)
-}
-
-func Munmap(b []byte) (err error) {
-	return mapper.Munmap(b)
-}
-
-func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
-	xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset)
-	return unsafe.Pointer(xaddr), err
-}
-
-func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
-	return mapper.munmap(uintptr(addr), length)
-}
-
-//sys   Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A
-//sysnb	Getgid() (gid int)
-//sysnb	Getpid() (pid int)
-//sysnb	Getpgid(pid int) (pgid int, err error) = SYS_GETPGID
-
-func Getpgrp() (pid int) {
-	pid, _ = Getpgid(0)
-	return
-}
-
-//sysnb	Getppid() (pid int)
-//sys	Getpriority(which int, who int) (prio int, err error)
-//sysnb	Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_GETRLIMIT
-
-//sysnb getrusage(who int, rusage *rusage_zos) (err error) = SYS_GETRUSAGE
-
-func Getrusage(who int, rusage *Rusage) (err error) {
-	var ruz rusage_zos
-	err = getrusage(who, &ruz)
-	//Only the first two fields of Rusage are set
-	rusage.Utime.Sec = ruz.Utime.Sec
-	rusage.Utime.Usec = int64(ruz.Utime.Usec)
-	rusage.Stime.Sec = ruz.Stime.Sec
-	rusage.Stime.Usec = int64(ruz.Stime.Usec)
-	return
-}
-
-//sys	Getegid() (egid int) = SYS_GETEGID
-//sys	Geteuid() (euid int) = SYS_GETEUID
-//sysnb Getsid(pid int) (sid int, err error) = SYS_GETSID
-//sysnb	Getuid() (uid int)
-//sysnb	Kill(pid int, sig Signal) (err error)
-//sys	Lchown(path string, uid int, gid int) (err error) = SYS___LCHOWN_A
-//sys	Link(path string, link string) (err error) = SYS___LINK_A
-//sys	Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) = SYS___LINKAT_A
-//sys	Listen(s int, n int) (err error)
-//sys	lstat(path string, stat *Stat_LE_t) (err error) = SYS___LSTAT_A
-
-func Lstat(path string, stat *Stat_t) (err error) {
-	var statLE Stat_LE_t
-	err = lstat(path, &statLE)
-	copyStat(stat, &statLE)
-	return
-}
-
-// for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/
-func isSpecialPath(path []byte) (v bool) {
-	var special = [4][8]byte{
-		{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'},
-		{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'},
-		{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'},
-		{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}}
-
-	var i, j int
-	for i = 0; i < len(special); i++ {
-		for j = 0; j < len(special[i]); j++ {
-			if path[j] != special[i][j] {
-				break
-			}
-		}
-		if j == len(special[i]) {
-			return true
-		}
-	}
-	return false
-}
-
-func realpath(srcpath string, abspath []byte) (pathlen int, errno int) {
-	var source [1024]byte
-	copy(source[:], srcpath)
-	source[len(srcpath)] = 0
-	ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___REALPATH_A<<4, //__realpath_a()
-		[]uintptr{uintptr(unsafe.Pointer(&source[0])),
-			uintptr(unsafe.Pointer(&abspath[0]))})
-	if ret != 0 {
-		index := bytes.IndexByte(abspath[:], byte(0))
-		if index != -1 {
-			return index, 0
-		}
-	} else {
-		errptr := (*int)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{}))) //__errno()
-		return 0, *errptr
-	}
-	return 0, 245 // EBADDATA   245
-}
-
-func Readlink(path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	n = int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___READLINK_A<<4,
-		[]uintptr{uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))}))
-	runtime.KeepAlive(unsafe.Pointer(_p0))
-	if n == -1 {
-		value := *(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{})))
-		err = errnoErr(Errno(value))
-	} else {
-		if buf[0] == '$' {
-			if isSpecialPath(buf[1:9]) {
-				cnt, err1 := realpath(path, buf)
-				if err1 == 0 {
-					n = cnt
-				}
-			}
-		}
-	}
-	return
-}
-
-func impl_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	var _p1 unsafe.Pointer
-	if len(buf) > 0 {
-		_p1 = unsafe.Pointer(&buf[0])
-	} else {
-		_p1 = unsafe.Pointer(&_zero)
-	}
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READLINKAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
-	runtime.ExitSyscall()
-	n = int(r0)
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-		return n, err
-	} else {
-		if buf[0] == '$' {
-			if isSpecialPath(buf[1:9]) {
-				cnt, err1 := realpath(path, buf)
-				if err1 == 0 {
-					n = cnt
-				}
-			}
-		}
-	}
-	return
-}
-
-//go:nosplit
-func get_ReadlinkatAddr() *(func(dirfd int, path string, buf []byte) (n int, err error))
-
-var Readlinkat = enter_Readlinkat
-
-func enter_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
-	funcref := get_ReadlinkatAddr()
-	if funcptrtest(GetZosLibVec()+SYS___READLINKAT_A<<4, "") == 0 {
-		*funcref = impl_Readlinkat
-	} else {
-		*funcref = error_Readlinkat
-	}
-	return (*funcref)(dirfd, path, buf)
-}
-
-func error_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
-	n = -1
-	err = ENOSYS
-	return
-}
-
-//sys	Mkdir(path string, mode uint32) (err error) = SYS___MKDIR_A
-//sys	Mkdirat(dirfd int, path string, mode uint32) (err error) = SYS___MKDIRAT_A
-//sys   Mkfifo(path string, mode uint32) (err error) = SYS___MKFIFO_A
-//sys	Mknod(path string, mode uint32, dev int) (err error) = SYS___MKNOD_A
-//sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error) = SYS___MKNODAT_A
-//sys	PivotRoot(newroot string, oldroot string) (err error) = SYS___PIVOT_ROOT_A
-//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
-//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
-//sys	Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) = SYS___PRCTL_A
-//sysnb	Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT
-//sys	Rename(from string, to string) (err error) = SYS___RENAME_A
-//sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) = SYS___RENAMEAT_A
-//sys	Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) = SYS___RENAMEAT2_A
-//sys	Rmdir(path string) (err error) = SYS___RMDIR_A
-//sys   Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK
-//sys	Setegid(egid int) (err error) = SYS_SETEGID
-//sys	Seteuid(euid int) (err error) = SYS_SETEUID
-//sys	Sethostname(p []byte) (err error) = SYS___SETHOSTNAME_A
-//sys   Setns(fd int, nstype int) (err error) = SYS_SETNS
-//sys	Setpriority(which int, who int, prio int) (err error)
-//sysnb	Setpgid(pid int, pgid int) (err error) = SYS_SETPGID
-//sysnb	Setrlimit(resource int, lim *Rlimit) (err error)
-//sysnb	Setregid(rgid int, egid int) (err error) = SYS_SETREGID
-//sysnb	Setreuid(ruid int, euid int) (err error) = SYS_SETREUID
-//sysnb	Setsid() (pid int, err error) = SYS_SETSID
-//sys	Setuid(uid int) (err error) = SYS_SETUID
-//sys	Setgid(uid int) (err error) = SYS_SETGID
-//sys	Shutdown(fd int, how int) (err error)
-//sys	stat(path string, statLE *Stat_LE_t) (err error) = SYS___STAT_A
-
-func Stat(path string, sta *Stat_t) (err error) {
-	var statLE Stat_LE_t
-	err = stat(path, &statLE)
-	copyStat(sta, &statLE)
-	return
-}
-
-//sys	Symlink(path string, link string) (err error) = SYS___SYMLINK_A
-//sys	Symlinkat(oldPath string, dirfd int, newPath string) (err error) = SYS___SYMLINKAT_A
-//sys	Sync() = SYS_SYNC
-//sys	Truncate(path string, length int64) (err error) = SYS___TRUNCATE_A
-//sys	Tcgetattr(fildes int, termptr *Termios) (err error) = SYS_TCGETATTR
-//sys	Tcsetattr(fildes int, when int, termptr *Termios) (err error) = SYS_TCSETATTR
-//sys	Umask(mask int) (oldmask int)
-//sys	Unlink(path string) (err error) = SYS___UNLINK_A
-//sys	Unlinkat(dirfd int, path string, flags int) (err error) = SYS___UNLINKAT_A
-//sys	Utime(path string, utim *Utimbuf) (err error) = SYS___UTIME_A
-
-//sys	open(path string, mode int, perm uint32) (fd int, err error) = SYS___OPEN_A
-
-func Open(path string, mode int, perm uint32) (fd int, err error) {
-	if mode&O_ACCMODE == 0 {
-		mode |= O_RDONLY
-	}
-	return open(path, mode, perm)
-}
-
-//sys	openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) = SYS___OPENAT_A
-
-func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
-	if flags&O_ACCMODE == 0 {
-		flags |= O_RDONLY
-	}
-	return openat(dirfd, path, flags, mode)
-}
-
-//sys	openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) = SYS___OPENAT2_A
-
-func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) {
-	if how.Flags&O_ACCMODE == 0 {
-		how.Flags |= O_RDONLY
-	}
-	return openat2(dirfd, path, how, SizeofOpenHow)
-}
-
-func ZosFdToPath(dirfd int) (path string, err error) {
-	var buffer [1024]byte
-	runtime.EnterSyscall()
-	ret, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_W_IOCTL<<4, uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0])))
-	runtime.ExitSyscall()
-	if ret == 0 {
-		zb := bytes.IndexByte(buffer[:], 0)
-		if zb == -1 {
-			zb = len(buffer)
-		}
-		CallLeFuncWithErr(GetZosLibVec()+SYS___E2A_L<<4, uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb))
-		return string(buffer[:zb]), nil
-	}
-	return "", errnoErr2(e1, e2)
-}
-
-//sys	remove(path string) (err error)
-
-func Remove(path string) error {
-	return remove(path)
-}
-
-const ImplementsGetwd = true
-
-func Getcwd(buf []byte) (n int, err error) {
-	var p unsafe.Pointer
-	if len(buf) > 0 {
-		p = unsafe.Pointer(&buf[0])
-	} else {
-		p = unsafe.Pointer(&_zero)
-	}
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___GETCWD_A<<4, uintptr(p), uintptr(len(buf)))
-	runtime.ExitSyscall()
-	n = clen(buf) + 1
-	if r0 == 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Getwd() (wd string, err error) {
-	var buf [PathMax]byte
-	n, err := Getcwd(buf[0:])
-	if err != nil {
-		return "", err
-	}
-	// Getcwd returns the number of bytes written to buf, including the NUL.
-	if n < 1 || n > len(buf) || buf[n-1] != 0 {
-		return "", EINVAL
-	}
-	return string(buf[0 : n-1]), nil
-}
-
-func Getgroups() (gids []int, err error) {
-	n, err := getgroups(0, nil)
-	if err != nil {
-		return nil, err
-	}
-	if n == 0 {
-		return nil, nil
-	}
-
-	// Sanity check group count.  Max is 1<<16 on Linux.
-	if n < 0 || n > 1<<20 {
-		return nil, EINVAL
-	}
-
-	a := make([]_Gid_t, n)
-	n, err = getgroups(n, &a[0])
-	if err != nil {
-		return nil, err
-	}
-	gids = make([]int, n)
-	for i, v := range a[0:n] {
-		gids[i] = int(v)
-	}
-	return
-}
-
-func Setgroups(gids []int) (err error) {
-	if len(gids) == 0 {
-		return setgroups(0, nil)
-	}
-
-	a := make([]_Gid_t, len(gids))
-	for i, v := range gids {
-		a[i] = _Gid_t(v)
-	}
-	return setgroups(len(a), &a[0])
-}
-
-func gettid() uint64
-
-func Gettid() (tid int) {
-	return int(gettid())
-}
-
-type WaitStatus uint32
-
-// Wait status is 7 bits at bottom, either 0 (exited),
-// 0x7F (stopped), or a signal number that caused an exit.
-// The 0x80 bit is whether there was a core dump.
-// An extra number (exit code, signal causing a stop)
-// is in the high bits.  At least that's the idea.
-// There are various irregularities.  For example, the
-// "continued" status is 0xFFFF, distinguishing itself
-// from stopped via the core dump bit.
-
-const (
-	mask    = 0x7F
-	core    = 0x80
-	exited  = 0x00
-	stopped = 0x7F
-	shift   = 8
-)
-
-func (w WaitStatus) Exited() bool { return w&mask == exited }
-
-func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }
-
-func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }
-
-func (w WaitStatus) Continued() bool { return w == 0xFFFF }
-
-func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
-
-func (w WaitStatus) ExitStatus() int {
-	if !w.Exited() {
-		return -1
-	}
-	return int(w>>shift) & 0xFF
-}
-
-func (w WaitStatus) Signal() Signal {
-	if !w.Signaled() {
-		return -1
-	}
-	return Signal(w & mask)
-}
-
-func (w WaitStatus) StopSignal() Signal {
-	if !w.Stopped() {
-		return -1
-	}
-	return Signal(w>>shift) & 0xFF
-}
-
-func (w WaitStatus) TrapCause() int { return -1 }
-
-//sys	waitid(idType int, id int, info *Siginfo, options int) (err error)
-
-func Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error) {
-	return waitid(idType, id, info, options)
-}
-
-//sys	waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error)
-
-func impl_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAIT4<<4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)))
-	runtime.ExitSyscall()
-	wpid = int(r0)
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_Wait4Addr() *(func(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error))
-
-var Wait4 = enter_Wait4
-
-func enter_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
-	funcref := get_Wait4Addr()
-	if funcptrtest(GetZosLibVec()+SYS_WAIT4<<4, "") == 0 {
-		*funcref = impl_Wait4
-	} else {
-		*funcref = legacyWait4
-	}
-	return (*funcref)(pid, wstatus, options, rusage)
-}
-
-func legacyWait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
-	// TODO(mundaym): z/OS doesn't have wait4. I don't think getrusage does what we want.
-	// At the moment rusage will not be touched.
-	var status _C_int
-	wpid, err = waitpid(pid, &status, options)
-	if wstatus != nil {
-		*wstatus = WaitStatus(status)
-	}
-	return
-}
-
-//sysnb	gettimeofday(tv *timeval_zos) (err error)
-
-func Gettimeofday(tv *Timeval) (err error) {
-	var tvz timeval_zos
-	err = gettimeofday(&tvz)
-	tv.Sec = tvz.Sec
-	tv.Usec = int64(tvz.Usec)
-	return
-}
-
-func Time(t *Time_t) (tt Time_t, err error) {
-	var tv Timeval
-	err = Gettimeofday(&tv)
-	if err != nil {
-		return 0, err
-	}
-	if t != nil {
-		*t = Time_t(tv.Sec)
-	}
-	return Time_t(tv.Sec), nil
-}
-
-func setTimespec(sec, nsec int64) Timespec {
-	return Timespec{Sec: sec, Nsec: nsec}
-}
-
-func setTimeval(sec, usec int64) Timeval { //fix
-	return Timeval{Sec: sec, Usec: usec}
-}
-
-//sysnb pipe(p *[2]_C_int) (err error)
-
-func Pipe(p []int) (err error) {
-	if len(p) != 2 {
-		return EINVAL
-	}
-	var pp [2]_C_int
-	err = pipe(&pp)
-	p[0] = int(pp[0])
-	p[1] = int(pp[1])
-	return
-}
-
-//sys	utimes(path string, timeval *[2]Timeval) (err error) = SYS___UTIMES_A
-
-func Utimes(path string, tv []Timeval) (err error) {
-	if tv == nil {
-		return utimes(path, nil)
-	}
-	if len(tv) != 2 {
-		return EINVAL
-	}
-	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
-}
-
-//sys	utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) = SYS___UTIMENSAT_A
-
-func validUtimensat() bool {
-	if funcptrtest(GetZosLibVec()+SYS___UTIMENSAT_A<<4, "") == 0 {
-		if name, err := getLeFuncName(GetZosLibVec() + SYS___UTIMENSAT_A<<4); err == nil {
-			return name == "__utimensat_a"
-		}
-	}
-	return false
-}
-
-// Begin UtimesNano
-
-//go:nosplit
-func get_UtimesNanoAddr() *(func(path string, ts []Timespec) (err error))
-
-var UtimesNano = enter_UtimesNano
-
-func enter_UtimesNano(path string, ts []Timespec) (err error) {
-	funcref := get_UtimesNanoAddr()
-	if validUtimensat() {
-		*funcref = utimesNanoImpl
-	} else {
-		*funcref = legacyUtimesNano
-	}
-	return (*funcref)(path, ts)
-}
-
-func utimesNanoImpl(path string, ts []Timespec) (err error) {
-	if ts == nil {
-		return utimensat(AT_FDCWD, path, nil, 0)
-	}
-	if len(ts) != 2 {
-		return EINVAL
-	}
-	return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
-}
-
-func legacyUtimesNano(path string, ts []Timespec) (err error) {
-	if len(ts) != 2 {
-		return EINVAL
-	}
-	// Not as efficient as it could be because Timespec and
-	// Timeval have different types in the different OSes
-	tv := [2]Timeval{
-		NsecToTimeval(TimespecToNsec(ts[0])),
-		NsecToTimeval(TimespecToNsec(ts[1])),
-	}
-	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
-}
-
-// End UtimesNano
-
-// Begin UtimesNanoAt
-
-//go:nosplit
-func get_UtimesNanoAtAddr() *(func(dirfd int, path string, ts []Timespec, flags int) (err error))
-
-var UtimesNanoAt = enter_UtimesNanoAt
-
-func enter_UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) {
-	funcref := get_UtimesNanoAtAddr()
-	if validUtimensat() {
-		*funcref = utimesNanoAtImpl
-	} else {
-		*funcref = legacyUtimesNanoAt
-	}
-	return (*funcref)(dirfd, path, ts, flags)
-}
-
-func utimesNanoAtImpl(dirfd int, path string, ts []Timespec, flags int) (err error) {
-	if ts == nil {
-		return utimensat(dirfd, path, nil, flags)
-	}
-	if len(ts) != 2 {
-		return EINVAL
-	}
-	return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
-}
-
-func legacyUtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) {
-	if path[0] != '/' {
-		dirPath, err := ZosFdToPath(dirfd)
-		if err != nil {
-			return err
-		}
-		path = dirPath + "/" + path
-	}
-	if flags == AT_SYMLINK_NOFOLLOW {
-		if len(ts) != 2 {
-			return EINVAL
-		}
-
-		if ts[0].Nsec >= 5e8 {
-			ts[0].Sec++
-		}
-		ts[0].Nsec = 0
-		if ts[1].Nsec >= 5e8 {
-			ts[1].Sec++
-		}
-		ts[1].Nsec = 0
-
-		// Not as efficient as it could be because Timespec and
-		// Timeval have different types in the different OSes
-		tv := []Timeval{
-			NsecToTimeval(TimespecToNsec(ts[0])),
-			NsecToTimeval(TimespecToNsec(ts[1])),
-		}
-		return Lutimes(path, tv)
-	}
-	return UtimesNano(path, ts)
-}
-
-// End UtimesNanoAt
-
-func Getsockname(fd int) (sa Sockaddr, err error) {
-	var rsa RawSockaddrAny
-	var len _Socklen = SizeofSockaddrAny
-	if err = getsockname(fd, &rsa, &len); err != nil {
-		return
-	}
-	// TODO(neeilan) : Remove this 0 ( added to get sys/unix compiling on z/OS )
-	return anyToSockaddr(0, &rsa)
-}
-
-const (
-	// identifier constants
-	nwmHeaderIdentifier    = 0xd5e6d4c8
-	nwmFilterIdentifier    = 0xd5e6d4c6
-	nwmTCPConnIdentifier   = 0xd5e6d4c3
-	nwmRecHeaderIdentifier = 0xd5e6d4d9
-	nwmIPStatsIdentifier   = 0xd5e6d4c9d7e2e340
-	nwmIPGStatsIdentifier  = 0xd5e6d4c9d7c7e2e3
-	nwmTCPStatsIdentifier  = 0xd5e6d4e3c3d7e2e3
-	nwmUDPStatsIdentifier  = 0xd5e6d4e4c4d7e2e3
-	nwmICMPGStatsEntry     = 0xd5e6d4c9c3d4d7c7
-	nwmICMPTStatsEntry     = 0xd5e6d4c9c3d4d7e3
-
-	// nwmHeader constants
-	nwmVersion1   = 1
-	nwmVersion2   = 2
-	nwmCurrentVer = 2
-
-	nwmTCPConnType     = 1
-	nwmGlobalStatsType = 14
-
-	// nwmFilter constants
-	nwmFilterLclAddrMask = 0x20000000 // Local address
-	nwmFilterSrcAddrMask = 0x20000000 // Source address
-	nwmFilterLclPortMask = 0x10000000 // Local port
-	nwmFilterSrcPortMask = 0x10000000 // Source port
-
-	// nwmConnEntry constants
-	nwmTCPStateClosed   = 1
-	nwmTCPStateListen   = 2
-	nwmTCPStateSynSent  = 3
-	nwmTCPStateSynRcvd  = 4
-	nwmTCPStateEstab    = 5
-	nwmTCPStateFinWait1 = 6
-	nwmTCPStateFinWait2 = 7
-	nwmTCPStateClosWait = 8
-	nwmTCPStateLastAck  = 9
-	nwmTCPStateClosing  = 10
-	nwmTCPStateTimeWait = 11
-	nwmTCPStateDeletTCB = 12
-
-	// Existing constants on linux
-	BPF_TCP_CLOSE        = 1
-	BPF_TCP_LISTEN       = 2
-	BPF_TCP_SYN_SENT     = 3
-	BPF_TCP_SYN_RECV     = 4
-	BPF_TCP_ESTABLISHED  = 5
-	BPF_TCP_FIN_WAIT1    = 6
-	BPF_TCP_FIN_WAIT2    = 7
-	BPF_TCP_CLOSE_WAIT   = 8
-	BPF_TCP_LAST_ACK     = 9
-	BPF_TCP_CLOSING      = 10
-	BPF_TCP_TIME_WAIT    = 11
-	BPF_TCP_NEW_SYN_RECV = -1
-	BPF_TCP_MAX_STATES   = -2
-)
-
-type nwmTriplet struct {
-	offset uint32
-	length uint32
-	number uint32
-}
-
-type nwmQuadruplet struct {
-	offset uint32
-	length uint32
-	number uint32
-	match  uint32
-}
-
-type nwmHeader struct {
-	ident       uint32
-	length      uint32
-	version     uint16
-	nwmType     uint16
-	bytesNeeded uint32
-	options     uint32
-	_           [16]byte
-	inputDesc   nwmTriplet
-	outputDesc  nwmQuadruplet
-}
-
-type nwmFilter struct {
-	ident         uint32
-	flags         uint32
-	resourceName  [8]byte
-	resourceId    uint32
-	listenerId    uint32
-	local         [28]byte // union of sockaddr4 and sockaddr6
-	remote        [28]byte // union of sockaddr4 and sockaddr6
-	_             uint16
-	_             uint16
-	asid          uint16
-	_             [2]byte
-	tnLuName      [8]byte
-	tnMonGrp      uint32
-	tnAppl        [8]byte
-	applData      [40]byte
-	nInterface    [16]byte
-	dVipa         [16]byte
-	dVipaPfx      uint16
-	dVipaPort     uint16
-	dVipaFamily   byte
-	_             [3]byte
-	destXCF       [16]byte
-	destXCFPfx    uint16
-	destXCFFamily byte
-	_             [1]byte
-	targIP        [16]byte
-	targIPPfx     uint16
-	targIPFamily  byte
-	_             [1]byte
-	_             [20]byte
-}
-
-type nwmRecHeader struct {
-	ident  uint32
-	length uint32
-	number byte
-	_      [3]byte
-}
-
-type nwmTCPStatsEntry struct {
-	ident             uint64
-	currEstab         uint32
-	activeOpened      uint32
-	passiveOpened     uint32
-	connClosed        uint32
-	estabResets       uint32
-	attemptFails      uint32
-	passiveDrops      uint32
-	timeWaitReused    uint32
-	inSegs            uint64
-	predictAck        uint32
-	predictData       uint32
-	inDupAck          uint32
-	inBadSum          uint32
-	inBadLen          uint32
-	inShort           uint32
-	inDiscOldTime     uint32
-	inAllBeforeWin    uint32
-	inSomeBeforeWin   uint32
-	inAllAfterWin     uint32
-	inSomeAfterWin    uint32
-	inOutOfOrder      uint32
-	inAfterClose      uint32
-	inWinProbes       uint32
-	inWinUpdates      uint32
-	outWinUpdates     uint32
-	outSegs           uint64
-	outDelayAcks      uint32
-	outRsts           uint32
-	retransSegs       uint32
-	retransTimeouts   uint32
-	retransDrops      uint32
-	pmtuRetrans       uint32
-	pmtuErrors        uint32
-	outWinProbes      uint32
-	probeDrops        uint32
-	keepAliveProbes   uint32
-	keepAliveDrops    uint32
-	finwait2Drops     uint32
-	acceptCount       uint64
-	inBulkQSegs       uint64
-	inDiscards        uint64
-	connFloods        uint32
-	connStalls        uint32
-	cfgEphemDef       uint16
-	ephemInUse        uint16
-	ephemHiWater      uint16
-	flags             byte
-	_                 [1]byte
-	ephemExhaust      uint32
-	smcRCurrEstabLnks uint32
-	smcRLnkActTimeOut uint32
-	smcRActLnkOpened  uint32
-	smcRPasLnkOpened  uint32
-	smcRLnksClosed    uint32
-	smcRCurrEstab     uint32
-	smcRActiveOpened  uint32
-	smcRPassiveOpened uint32
-	smcRConnClosed    uint32
-	smcRInSegs        uint64
-	smcROutSegs       uint64
-	smcRInRsts        uint32
-	smcROutRsts       uint32
-	smcDCurrEstabLnks uint32
-	smcDActLnkOpened  uint32
-	smcDPasLnkOpened  uint32
-	smcDLnksClosed    uint32
-	smcDCurrEstab     uint32
-	smcDActiveOpened  uint32
-	smcDPassiveOpened uint32
-	smcDConnClosed    uint32
-	smcDInSegs        uint64
-	smcDOutSegs       uint64
-	smcDInRsts        uint32
-	smcDOutRsts       uint32
-}
-
-type nwmConnEntry struct {
-	ident             uint32
-	local             [28]byte // union of sockaddr4 and sockaddr6
-	remote            [28]byte // union of sockaddr4 and sockaddr6
-	startTime         [8]byte  // uint64, changed to prevent padding from being inserted
-	lastActivity      [8]byte  // uint64
-	bytesIn           [8]byte  // uint64
-	bytesOut          [8]byte  // uint64
-	inSegs            [8]byte  // uint64
-	outSegs           [8]byte  // uint64
-	state             uint16
-	activeOpen        byte
-	flag01            byte
-	outBuffered       uint32
-	inBuffered        uint32
-	maxSndWnd         uint32
-	reXmtCount        uint32
-	congestionWnd     uint32
-	ssThresh          uint32
-	roundTripTime     uint32
-	roundTripVar      uint32
-	sendMSS           uint32
-	sndWnd            uint32
-	rcvBufSize        uint32
-	sndBufSize        uint32
-	outOfOrderCount   uint32
-	lcl0WindowCount   uint32
-	rmt0WindowCount   uint32
-	dupacks           uint32
-	flag02            byte
-	sockOpt6Cont      byte
-	asid              uint16
-	resourceName      [8]byte
-	resourceId        uint32
-	subtask           uint32
-	sockOpt           byte
-	sockOpt6          byte
-	clusterConnFlag   byte
-	proto             byte
-	targetAppl        [8]byte
-	luName            [8]byte
-	clientUserId      [8]byte
-	logMode           [8]byte
-	timeStamp         uint32
-	timeStampAge      uint32
-	serverResourceId  uint32
-	intfName          [16]byte
-	ttlsStatPol       byte
-	ttlsStatConn      byte
-	ttlsSSLProt       uint16
-	ttlsNegCiph       [2]byte
-	ttlsSecType       byte
-	ttlsFIPS140Mode   byte
-	ttlsUserID        [8]byte
-	applData          [40]byte
-	inOldestTime      [8]byte // uint64
-	outOldestTime     [8]byte // uint64
-	tcpTrustedPartner byte
-	_                 [3]byte
-	bulkDataIntfName  [16]byte
-	ttlsNegCiph4      [4]byte
-	smcReason         uint32
-	lclSMCLinkId      uint32
-	rmtSMCLinkId      uint32
-	smcStatus         byte
-	smcFlags          byte
-	_                 [2]byte
-	rcvWnd            uint32
-	lclSMCBufSz       uint32
-	rmtSMCBufSz       uint32
-	ttlsSessID        [32]byte
-	ttlsSessIDLen     int16
-	_                 [1]byte
-	smcDStatus        byte
-	smcDReason        uint32
-}
-
-var svcNameTable [][]byte = [][]byte{
-	[]byte("\xc5\xe9\xc2\xd5\xd4\xc9\xc6\xf4"), // svc_EZBNMIF4
-}
-
-const (
-	svc_EZBNMIF4 = 0
-)
-
-func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
-	jobname := []byte("\x5c\x40\x40\x40\x40\x40\x40\x40") // "*"
-	responseBuffer := [4096]byte{0}
-	var bufferAlet, reasonCode uint32 = 0, 0
-	var bufferLen, returnValue, returnCode int32 = 4096, 0, 0
-
-	dsa := [18]uint64{0}
-	var argv [7]unsafe.Pointer
-	argv[0] = unsafe.Pointer(&jobname[0])
-	argv[1] = unsafe.Pointer(&responseBuffer[0])
-	argv[2] = unsafe.Pointer(&bufferAlet)
-	argv[3] = unsafe.Pointer(&bufferLen)
-	argv[4] = unsafe.Pointer(&returnValue)
-	argv[5] = unsafe.Pointer(&returnCode)
-	argv[6] = unsafe.Pointer(&reasonCode)
-
-	request := (*struct {
-		header nwmHeader
-		filter nwmFilter
-	})(unsafe.Pointer(&responseBuffer[0]))
-
-	EZBNMIF4 := svcLoad(&svcNameTable[svc_EZBNMIF4][0])
-	if EZBNMIF4 == nil {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// GetGlobalStats EZBNMIF4 call
-	request.header.ident = nwmHeaderIdentifier
-	request.header.length = uint32(unsafe.Sizeof(request.header))
-	request.header.version = nwmCurrentVer
-	request.header.nwmType = nwmGlobalStatsType
-	request.header.options = 0x80000000
-
-	svcCall(EZBNMIF4, &argv[0], &dsa[0])
-
-	// outputDesc field is filled by EZBNMIF4 on success
-	if returnCode != 0 || request.header.outputDesc.offset == 0 {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// Check that EZBNMIF4 returned a nwmRecHeader
-	recHeader := (*nwmRecHeader)(unsafe.Pointer(&responseBuffer[request.header.outputDesc.offset]))
-	if recHeader.ident != nwmRecHeaderIdentifier {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// Parse nwmTriplets to get offsets of returned entries
-	var sections []*uint64
-	var sectionDesc *nwmTriplet = (*nwmTriplet)(unsafe.Pointer(&responseBuffer[0]))
-	for i := uint32(0); i < uint32(recHeader.number); i++ {
-		offset := request.header.outputDesc.offset + uint32(unsafe.Sizeof(*recHeader)) + i*uint32(unsafe.Sizeof(*sectionDesc))
-		sectionDesc = (*nwmTriplet)(unsafe.Pointer(&responseBuffer[offset]))
-		for j := uint32(0); j < sectionDesc.number; j++ {
-			offset = request.header.outputDesc.offset + sectionDesc.offset + j*sectionDesc.length
-			sections = append(sections, (*uint64)(unsafe.Pointer(&responseBuffer[offset])))
-		}
-	}
-
-	// Find nwmTCPStatsEntry in returned entries
-	var tcpStats *nwmTCPStatsEntry = nil
-	for _, ptr := range sections {
-		switch *ptr {
-		case nwmTCPStatsIdentifier:
-			if tcpStats != nil {
-				return nil, errnoErr(EINVAL)
-			}
-			tcpStats = (*nwmTCPStatsEntry)(unsafe.Pointer(ptr))
-		case nwmIPStatsIdentifier:
-		case nwmIPGStatsIdentifier:
-		case nwmUDPStatsIdentifier:
-		case nwmICMPGStatsEntry:
-		case nwmICMPTStatsEntry:
-		default:
-			return nil, errnoErr(EINVAL)
-		}
-	}
-	if tcpStats == nil {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// GetConnectionDetail EZBNMIF4 call
-	responseBuffer = [4096]byte{0}
-	dsa = [18]uint64{0}
-	bufferAlet, reasonCode = 0, 0
-	bufferLen, returnValue, returnCode = 4096, 0, 0
-	nameptr := (*uint32)(unsafe.Pointer(uintptr(0x21c))) // Get jobname of current process
-	nameptr = (*uint32)(unsafe.Pointer(uintptr(*nameptr + 12)))
-	argv[0] = unsafe.Pointer(uintptr(*nameptr))
-
-	request.header.ident = nwmHeaderIdentifier
-	request.header.length = uint32(unsafe.Sizeof(request.header))
-	request.header.version = nwmCurrentVer
-	request.header.nwmType = nwmTCPConnType
-	request.header.options = 0x80000000
-
-	request.filter.ident = nwmFilterIdentifier
-
-	var localSockaddr RawSockaddrAny
-	socklen := _Socklen(SizeofSockaddrAny)
-	err := getsockname(fd, &localSockaddr, &socklen)
-	if err != nil {
-		return nil, errnoErr(EINVAL)
-	}
-	if localSockaddr.Addr.Family == AF_INET {
-		localSockaddr := (*RawSockaddrInet4)(unsafe.Pointer(&localSockaddr.Addr))
-		localSockFilter := (*RawSockaddrInet4)(unsafe.Pointer(&request.filter.local[0]))
-		localSockFilter.Family = AF_INET
-		var i int
-		for i = 0; i < 4; i++ {
-			if localSockaddr.Addr[i] != 0 {
-				break
-			}
-		}
-		if i != 4 {
-			request.filter.flags |= nwmFilterLclAddrMask
-			for i = 0; i < 4; i++ {
-				localSockFilter.Addr[i] = localSockaddr.Addr[i]
-			}
-		}
-		if localSockaddr.Port != 0 {
-			request.filter.flags |= nwmFilterLclPortMask
-			localSockFilter.Port = localSockaddr.Port
-		}
-	} else if localSockaddr.Addr.Family == AF_INET6 {
-		localSockaddr := (*RawSockaddrInet6)(unsafe.Pointer(&localSockaddr.Addr))
-		localSockFilter := (*RawSockaddrInet6)(unsafe.Pointer(&request.filter.local[0]))
-		localSockFilter.Family = AF_INET6
-		var i int
-		for i = 0; i < 16; i++ {
-			if localSockaddr.Addr[i] != 0 {
-				break
-			}
-		}
-		if i != 16 {
-			request.filter.flags |= nwmFilterLclAddrMask
-			for i = 0; i < 16; i++ {
-				localSockFilter.Addr[i] = localSockaddr.Addr[i]
-			}
-		}
-		if localSockaddr.Port != 0 {
-			request.filter.flags |= nwmFilterLclPortMask
-			localSockFilter.Port = localSockaddr.Port
-		}
-	}
-
-	svcCall(EZBNMIF4, &argv[0], &dsa[0])
-
-	// outputDesc field is filled by EZBNMIF4 on success
-	if returnCode != 0 || request.header.outputDesc.offset == 0 {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// Check that EZBNMIF4 returned a nwmConnEntry
-	conn := (*nwmConnEntry)(unsafe.Pointer(&responseBuffer[request.header.outputDesc.offset]))
-	if conn.ident != nwmTCPConnIdentifier {
-		return nil, errnoErr(EINVAL)
-	}
-
-	// Copy data from the returned data structures into tcpInfo
-	// Stats from nwmConnEntry are specific to that connection.
-	// Stats from nwmTCPStatsEntry are global (to the interface?)
-	// Fields may not be an exact match. Some fields have no equivalent.
-	var tcpinfo TCPInfo
-	tcpinfo.State = uint8(conn.state)
-	tcpinfo.Ca_state = 0 // dummy
-	tcpinfo.Retransmits = uint8(tcpStats.retransSegs)
-	tcpinfo.Probes = uint8(tcpStats.outWinProbes)
-	tcpinfo.Backoff = 0 // dummy
-	tcpinfo.Options = 0 // dummy
-	tcpinfo.Rto = tcpStats.retransTimeouts
-	tcpinfo.Ato = tcpStats.outDelayAcks
-	tcpinfo.Snd_mss = conn.sendMSS
-	tcpinfo.Rcv_mss = conn.sendMSS // dummy
-	tcpinfo.Unacked = 0            // dummy
-	tcpinfo.Sacked = 0             // dummy
-	tcpinfo.Lost = 0               // dummy
-	tcpinfo.Retrans = conn.reXmtCount
-	tcpinfo.Fackets = 0 // dummy
-	tcpinfo.Last_data_sent = uint32(*(*uint64)(unsafe.Pointer(&conn.lastActivity[0])))
-	tcpinfo.Last_ack_sent = uint32(*(*uint64)(unsafe.Pointer(&conn.outOldestTime[0])))
-	tcpinfo.Last_data_recv = uint32(*(*uint64)(unsafe.Pointer(&conn.inOldestTime[0])))
-	tcpinfo.Last_ack_recv = uint32(*(*uint64)(unsafe.Pointer(&conn.inOldestTime[0])))
-	tcpinfo.Pmtu = conn.sendMSS // dummy, NWMIfRouteMtu is a candidate
-	tcpinfo.Rcv_ssthresh = conn.ssThresh
-	tcpinfo.Rtt = conn.roundTripTime
-	tcpinfo.Rttvar = conn.roundTripVar
-	tcpinfo.Snd_ssthresh = conn.ssThresh // dummy
-	tcpinfo.Snd_cwnd = conn.congestionWnd
-	tcpinfo.Advmss = conn.sendMSS        // dummy
-	tcpinfo.Reordering = 0               // dummy
-	tcpinfo.Rcv_rtt = conn.roundTripTime // dummy
-	tcpinfo.Rcv_space = conn.sendMSS     // dummy
-	tcpinfo.Total_retrans = conn.reXmtCount
-
-	svcUnload(&svcNameTable[svc_EZBNMIF4][0], EZBNMIF4)
-
-	return &tcpinfo, nil
-}
-
-// GetsockoptString returns the string value of the socket option opt for the
-// socket associated with fd at the given socket level.
-func GetsockoptString(fd, level, opt int) (string, error) {
-	buf := make([]byte, 256)
-	vallen := _Socklen(len(buf))
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
-	if err != nil {
-		return "", err
-	}
-
-	return ByteSliceToString(buf[:vallen]), nil
-}
-
-func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
-	var msg Msghdr
-	var rsa RawSockaddrAny
-	msg.Name = (*byte)(unsafe.Pointer(&rsa))
-	msg.Namelen = SizeofSockaddrAny
-	var iov Iovec
-	if len(p) > 0 {
-		iov.Base = (*byte)(unsafe.Pointer(&p[0]))
-		iov.SetLen(len(p))
-	}
-	var dummy byte
-	if len(oob) > 0 {
-		// receive at least one normal byte
-		if len(p) == 0 {
-			iov.Base = &dummy
-			iov.SetLen(1)
-		}
-		msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
-		msg.SetControllen(len(oob))
-	}
-	msg.Iov = &iov
-	msg.Iovlen = 1
-	if n, err = recvmsg(fd, &msg, flags); err != nil {
-		return
-	}
-	oobn = int(msg.Controllen)
-	recvflags = int(msg.Flags)
-	// source address is only specified if the socket is unconnected
-	if rsa.Addr.Family != AF_UNSPEC {
-		// TODO(neeilan): Remove 0 arg added to get this compiling on z/OS
-		from, err = anyToSockaddr(0, &rsa)
-	}
-	return
-}
-
-func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
-	_, err = SendmsgN(fd, p, oob, to, flags)
-	return
-}
-
-func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
-	var ptr unsafe.Pointer
-	var salen _Socklen
-	if to != nil {
-		var err error
-		ptr, salen, err = to.sockaddr()
-		if err != nil {
-			return 0, err
-		}
-	}
-	var msg Msghdr
-	msg.Name = (*byte)(unsafe.Pointer(ptr))
-	msg.Namelen = int32(salen)
-	var iov Iovec
-	if len(p) > 0 {
-		iov.Base = (*byte)(unsafe.Pointer(&p[0]))
-		iov.SetLen(len(p))
-	}
-	var dummy byte
-	if len(oob) > 0 {
-		// send at least one normal byte
-		if len(p) == 0 {
-			iov.Base = &dummy
-			iov.SetLen(1)
-		}
-		msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
-		msg.SetControllen(len(oob))
-	}
-	msg.Iov = &iov
-	msg.Iovlen = 1
-	if n, err = sendmsg(fd, &msg, flags); err != nil {
-		return 0, err
-	}
-	if len(oob) > 0 && len(p) == 0 {
-		n = 0
-	}
-	return n, nil
-}
-
-func Opendir(name string) (uintptr, error) {
-	p, err := BytePtrFromString(name)
-	if err != nil {
-		return 0, err
-	}
-	err = nil
-	runtime.EnterSyscall()
-	dir, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___OPENDIR_A<<4, uintptr(unsafe.Pointer(p)))
-	runtime.ExitSyscall()
-	runtime.KeepAlive(unsafe.Pointer(p))
-	if dir == 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return dir, err
-}
-
-// clearsyscall.Errno resets the errno value to 0.
-func clearErrno()
-
-func Closedir(dir uintptr) error {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSEDIR<<4, dir)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		return errnoErr2(e1, e2)
-	}
-	return nil
-}
-
-func Seekdir(dir uintptr, pos int) {
-	runtime.EnterSyscall()
-	CallLeFuncWithErr(GetZosLibVec()+SYS_SEEKDIR<<4, dir, uintptr(pos))
-	runtime.ExitSyscall()
-}
-
-func Telldir(dir uintptr) (int, error) {
-	p, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TELLDIR<<4, dir)
-	pos := int(p)
-	if int64(p) == -1 {
-		return pos, errnoErr2(e1, e2)
-	}
-	return pos, nil
-}
-
-// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
-func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
-	// struct flock is packed on z/OS. We can't emulate that in Go so
-	// instead we pack it here.
-	var flock [24]byte
-	*(*int16)(unsafe.Pointer(&flock[0])) = lk.Type
-	*(*int16)(unsafe.Pointer(&flock[2])) = lk.Whence
-	*(*int64)(unsafe.Pointer(&flock[4])) = lk.Start
-	*(*int64)(unsafe.Pointer(&flock[12])) = lk.Len
-	*(*int32)(unsafe.Pointer(&flock[20])) = lk.Pid
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock)))
-	runtime.ExitSyscall()
-	lk.Type = *(*int16)(unsafe.Pointer(&flock[0]))
-	lk.Whence = *(*int16)(unsafe.Pointer(&flock[2]))
-	lk.Start = *(*int64)(unsafe.Pointer(&flock[4]))
-	lk.Len = *(*int64)(unsafe.Pointer(&flock[12]))
-	lk.Pid = *(*int32)(unsafe.Pointer(&flock[20]))
-	if r0 == 0 {
-		return nil
-	}
-	return errnoErr2(e1, e2)
-}
-
-func impl_Flock(fd int, how int) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FLOCK<<4, uintptr(fd), uintptr(how))
-	runtime.ExitSyscall()
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_FlockAddr() *(func(fd int, how int) (err error))
-
-var Flock = enter_Flock
-
-func validFlock(fp uintptr) bool {
-	if funcptrtest(GetZosLibVec()+SYS_FLOCK<<4, "") == 0 {
-		if name, err := getLeFuncName(GetZosLibVec() + SYS_FLOCK<<4); err == nil {
-			return name == "flock"
-		}
-	}
-	return false
-}
-
-func enter_Flock(fd int, how int) (err error) {
-	funcref := get_FlockAddr()
-	if validFlock(GetZosLibVec() + SYS_FLOCK<<4) {
-		*funcref = impl_Flock
-	} else {
-		*funcref = legacyFlock
-	}
-	return (*funcref)(fd, how)
-}
-
-func legacyFlock(fd int, how int) error {
-
-	var flock_type int16
-	var fcntl_cmd int
-
-	switch how {
-	case LOCK_SH | LOCK_NB:
-		flock_type = F_RDLCK
-		fcntl_cmd = F_SETLK
-	case LOCK_EX | LOCK_NB:
-		flock_type = F_WRLCK
-		fcntl_cmd = F_SETLK
-	case LOCK_EX:
-		flock_type = F_WRLCK
-		fcntl_cmd = F_SETLKW
-	case LOCK_UN:
-		flock_type = F_UNLCK
-		fcntl_cmd = F_SETLKW
-	default:
-	}
-
-	flock := Flock_t{
-		Type:   int16(flock_type),
-		Whence: int16(0),
-		Start:  int64(0),
-		Len:    int64(0),
-		Pid:    int32(Getppid()),
-	}
-
-	err := FcntlFlock(uintptr(fd), fcntl_cmd, &flock)
-	return err
-}
-
-func Mlock(b []byte) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Mlock2(b []byte, flags int) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Mlockall(flags int) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Munlock(b []byte) (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Munlockall() (err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP)
-	runtime.ExitSyscall()
-	if r0 != 0 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func ClockGettime(clockid int32, ts *Timespec) error {
-
-	var ticks_per_sec uint32 = 100 //TODO(kenan): value is currently hardcoded; need sysconf() call otherwise
-	var nsec_per_sec int64 = 1000000000
-
-	if ts == nil {
-		return EFAULT
-	}
-	if clockid == CLOCK_REALTIME || clockid == CLOCK_MONOTONIC {
-		var nanotime int64 = runtime.Nanotime1()
-		ts.Sec = nanotime / nsec_per_sec
-		ts.Nsec = nanotime % nsec_per_sec
-	} else if clockid == CLOCK_PROCESS_CPUTIME_ID || clockid == CLOCK_THREAD_CPUTIME_ID {
-		var tm Tms
-		_, err := Times(&tm)
-		if err != nil {
-			return EFAULT
-		}
-		ts.Sec = int64(tm.Utime / ticks_per_sec)
-		ts.Nsec = int64(tm.Utime) * nsec_per_sec / int64(ticks_per_sec)
-	} else {
-		return EINVAL
-	}
-	return nil
-}
-
-// Chtag
-
-//go:nosplit
-func get_ChtagAddr() *(func(path string, ccsid uint64, textbit uint64) error)
-
-var Chtag = enter_Chtag
-
-func enter_Chtag(path string, ccsid uint64, textbit uint64) error {
-	funcref := get_ChtagAddr()
-	if validSetxattr() {
-		*funcref = impl_Chtag
-	} else {
-		*funcref = legacy_Chtag
-	}
-	return (*funcref)(path, ccsid, textbit)
-}
-
-func legacy_Chtag(path string, ccsid uint64, textbit uint64) error {
-	tag := ccsid<<16 | textbit<<15
-	var tag_buff [8]byte
-	DecodeData(tag_buff[:], 8, tag)
-	return Setxattr(path, "filetag", tag_buff[:], XATTR_REPLACE)
-}
-
-func impl_Chtag(path string, ccsid uint64, textbit uint64) error {
-	tag := ccsid<<16 | textbit<<15
-	var tag_buff [4]byte
-	DecodeData(tag_buff[:], 4, tag)
-	return Setxattr(path, "system.filetag", tag_buff[:], XATTR_REPLACE)
-}
-
-// End of Chtag
-
-// Nanosleep
-
-//go:nosplit
-func get_NanosleepAddr() *(func(time *Timespec, leftover *Timespec) error)
-
-var Nanosleep = enter_Nanosleep
-
-func enter_Nanosleep(time *Timespec, leftover *Timespec) error {
-	funcref := get_NanosleepAddr()
-	if funcptrtest(GetZosLibVec()+SYS_NANOSLEEP<<4, "") == 0 {
-		*funcref = impl_Nanosleep
-	} else {
-		*funcref = legacyNanosleep
-	}
-	return (*funcref)(time, leftover)
-}
-
-func impl_Nanosleep(time *Timespec, leftover *Timespec) error {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_NANOSLEEP<<4, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)))
-	runtime.ExitSyscall()
-	if int64(r0) == -1 {
-		return errnoErr2(e1, e2)
-	}
-	return nil
-}
-
-func legacyNanosleep(time *Timespec, leftover *Timespec) error {
-	t0 := runtime.Nanotime1()
-	var secrem uint32
-	var nsecrem uint32
-	total := time.Sec*1000000000 + time.Nsec
-	elapsed := runtime.Nanotime1() - t0
-	var rv int32
-	var rc int32
-	var err error
-	// repeatedly sleep for 1 second until less than 1 second left
-	for total-elapsed > 1000000000 {
-		rv, rc, _ = BpxCondTimedWait(uint32(1), uint32(0), uint32(CW_CONDVAR), &secrem, &nsecrem)
-		if rv != 0 && rc != 112 { // 112 is EAGAIN
-			if leftover != nil && rc == 120 { // 120 is EINTR
-				leftover.Sec = int64(secrem)
-				leftover.Nsec = int64(nsecrem)
-			}
-			err = Errno(rc)
-			return err
-		}
-		elapsed = runtime.Nanotime1() - t0
-	}
-	// sleep the remainder
-	if total > elapsed {
-		rv, rc, _ = BpxCondTimedWait(uint32(0), uint32(total-elapsed), uint32(CW_CONDVAR), &secrem, &nsecrem)
-	}
-	if leftover != nil && rc == 120 {
-		leftover.Sec = int64(secrem)
-		leftover.Nsec = int64(nsecrem)
-	}
-	if rv != 0 && rc != 112 {
-		err = Errno(rc)
-	}
-	return err
-}
-
-// End of Nanosleep
-
-var (
-	Stdin  = 0
-	Stdout = 1
-	Stderr = 2
-)
-
-// Do the interface allocations only once for common
-// Errno values.
-var (
-	errEAGAIN error = syscall.EAGAIN
-	errEINVAL error = syscall.EINVAL
-	errENOENT error = syscall.ENOENT
-)
-
-var ZosTraceLevel int
-var ZosTracefile *os.File
-
-var (
-	signalNameMapOnce sync.Once
-	signalNameMap     map[string]syscall.Signal
-)
-
-// errnoErr returns common boxed Errno values, to prevent
-// allocations at runtime.
-func errnoErr(e Errno) error {
-	switch e {
-	case 0:
-		return nil
-	case EAGAIN:
-		return errEAGAIN
-	case EINVAL:
-		return errEINVAL
-	case ENOENT:
-		return errENOENT
-	}
-	return e
-}
-
-var reg *regexp.Regexp
-
-// enhanced with zos specific errno2
-func errnoErr2(e Errno, e2 uintptr) error {
-	switch e {
-	case 0:
-		return nil
-	case EAGAIN:
-		return errEAGAIN
-		/*
-			Allow the retrieval of errno2 for EINVAL and ENOENT on zos
-				case EINVAL:
-					return errEINVAL
-				case ENOENT:
-					return errENOENT
-		*/
-	}
-	if ZosTraceLevel > 0 {
-		var name string
-		if reg == nil {
-			reg = regexp.MustCompile("(^unix\\.[^/]+$|.*\\/unix\\.[^/]+$)")
-		}
-		i := 1
-		pc, file, line, ok := runtime.Caller(i)
-		if ok {
-			name = runtime.FuncForPC(pc).Name()
-		}
-		for ok && reg.MatchString(runtime.FuncForPC(pc).Name()) {
-			i += 1
-			pc, file, line, ok = runtime.Caller(i)
-		}
-		if ok {
-			if ZosTracefile == nil {
-				ZosConsolePrintf("From %s:%d\n", file, line)
-				ZosConsolePrintf("%s: %s (errno2=0x%x)\n", name, e.Error(), e2)
-			} else {
-				fmt.Fprintf(ZosTracefile, "From %s:%d\n", file, line)
-				fmt.Fprintf(ZosTracefile, "%s: %s (errno2=0x%x)\n", name, e.Error(), e2)
-			}
-		} else {
-			if ZosTracefile == nil {
-				ZosConsolePrintf("%s (errno2=0x%x)\n", e.Error(), e2)
-			} else {
-				fmt.Fprintf(ZosTracefile, "%s (errno2=0x%x)\n", e.Error(), e2)
-			}
-		}
-	}
-	return e
-}
-
-// ErrnoName returns the error name for error number e.
-func ErrnoName(e Errno) string {
-	i := sort.Search(len(errorList), func(i int) bool {
-		return errorList[i].num >= e
-	})
-	if i < len(errorList) && errorList[i].num == e {
-		return errorList[i].name
-	}
-	return ""
-}
-
-// SignalName returns the signal name for signal number s.
-func SignalName(s syscall.Signal) string {
-	i := sort.Search(len(signalList), func(i int) bool {
-		return signalList[i].num >= s
-	})
-	if i < len(signalList) && signalList[i].num == s {
-		return signalList[i].name
-	}
-	return ""
-}
-
-// SignalNum returns the syscall.Signal for signal named s,
-// or 0 if a signal with such name is not found.
-// The signal name should start with "SIG".
-func SignalNum(s string) syscall.Signal {
-	signalNameMapOnce.Do(func() {
-		signalNameMap = make(map[string]syscall.Signal, len(signalList))
-		for _, signal := range signalList {
-			signalNameMap[signal.name] = signal.num
-		}
-	})
-	return signalNameMap[s]
-}
-
-// clen returns the index of the first NULL byte in n or len(n) if n contains no NULL byte.
-func clen(n []byte) int {
-	i := bytes.IndexByte(n, 0)
-	if i == -1 {
-		i = len(n)
-	}
-	return i
-}
-
-// Mmap manager, for use by operating system-specific implementations.
-
-type mmapper struct {
-	sync.Mutex
-	active map[*byte][]byte // active mappings; key is last byte in mapping
-	mmap   func(addr, length uintptr, prot, flags, fd int, offset int64) (uintptr, error)
-	munmap func(addr uintptr, length uintptr) error
-}
-
-func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
-	if length <= 0 {
-		return nil, EINVAL
-	}
-
-	// Set __MAP_64 by default
-	flags |= __MAP_64
-
-	// Map the requested memory.
-	addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset)
-	if errno != nil {
-		return nil, errno
-	}
-
-	// Slice memory layout
-	var sl = struct {
-		addr uintptr
-		len  int
-		cap  int
-	}{addr, length, length}
-
-	// Use unsafe to turn sl into a []byte.
-	b := *(*[]byte)(unsafe.Pointer(&sl))
-
-	// Register mapping in m and return it.
-	p := &b[cap(b)-1]
-	m.Lock()
-	defer m.Unlock()
-	m.active[p] = b
-	return b, nil
-}
-
-func (m *mmapper) Munmap(data []byte) (err error) {
-	if len(data) == 0 || len(data) != cap(data) {
-		return EINVAL
-	}
-
-	// Find the base of the mapping.
-	p := &data[cap(data)-1]
-	m.Lock()
-	defer m.Unlock()
-	b := m.active[p]
-	if b == nil || &b[0] != &data[0] {
-		return EINVAL
-	}
-
-	// Unmap the memory and update m.
-	if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
-		return errno
-	}
-	delete(m.active, p)
-	return nil
-}
-
-func Read(fd int, p []byte) (n int, err error) {
-	n, err = read(fd, p)
-	if raceenabled {
-		if n > 0 {
-			raceWriteRange(unsafe.Pointer(&p[0]), n)
-		}
-		if err == nil {
-			raceAcquire(unsafe.Pointer(&ioSync))
-		}
-	}
-	return
-}
-
-func Write(fd int, p []byte) (n int, err error) {
-	if raceenabled {
-		raceReleaseMerge(unsafe.Pointer(&ioSync))
-	}
-	n, err = write(fd, p)
-	if raceenabled && n > 0 {
-		raceReadRange(unsafe.Pointer(&p[0]), n)
-	}
-	return
-}
-
-// For testing: clients can set this flag to force
-// creation of IPv6 sockets to return EAFNOSUPPORT.
-var SocketDisableIPv6 bool
-
-// Sockaddr represents a socket address.
-type Sockaddr interface {
-	sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
-}
-
-// SockaddrInet4 implements the Sockaddr interface for AF_INET type sockets.
-type SockaddrInet4 struct {
-	Port int
-	Addr [4]byte
-	raw  RawSockaddrInet4
-}
-
-// SockaddrInet6 implements the Sockaddr interface for AF_INET6 type sockets.
-type SockaddrInet6 struct {
-	Port   int
-	ZoneId uint32
-	Addr   [16]byte
-	raw    RawSockaddrInet6
-}
-
-// SockaddrUnix implements the Sockaddr interface for AF_UNIX type sockets.
-type SockaddrUnix struct {
-	Name string
-	raw  RawSockaddrUnix
-}
-
-func Bind(fd int, sa Sockaddr) (err error) {
-	ptr, n, err := sa.sockaddr()
-	if err != nil {
-		return err
-	}
-	return bind(fd, ptr, n)
-}
-
-func Connect(fd int, sa Sockaddr) (err error) {
-	ptr, n, err := sa.sockaddr()
-	if err != nil {
-		return err
-	}
-	return connect(fd, ptr, n)
-}
-
-func Getpeername(fd int) (sa Sockaddr, err error) {
-	var rsa RawSockaddrAny
-	var len _Socklen = SizeofSockaddrAny
-	if err = getpeername(fd, &rsa, &len); err != nil {
-		return
-	}
-	return anyToSockaddr(fd, &rsa)
-}
-
-func GetsockoptByte(fd, level, opt int) (value byte, err error) {
-	var n byte
-	vallen := _Socklen(1)
-	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
-	return n, err
-}
-
-func GetsockoptInt(fd, level, opt int) (value int, err error) {
-	var n int32
-	vallen := _Socklen(4)
-	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
-	return int(n), err
-}
-
-func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
-	vallen := _Socklen(4)
-	err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
-	return value, err
-}
-
-func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) {
-	var value IPMreq
-	vallen := _Socklen(SizeofIPMreq)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
-	return &value, err
-}
-
-func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
-	var value IPv6Mreq
-	vallen := _Socklen(SizeofIPv6Mreq)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
-	return &value, err
-}
-
-func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
-	var value IPv6MTUInfo
-	vallen := _Socklen(SizeofIPv6MTUInfo)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
-	return &value, err
-}
-
-func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
-	var value ICMPv6Filter
-	vallen := _Socklen(SizeofICMPv6Filter)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
-	return &value, err
-}
-
-func GetsockoptLinger(fd, level, opt int) (*Linger, error) {
-	var linger Linger
-	vallen := _Socklen(SizeofLinger)
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen)
-	return &linger, err
-}
-
-func GetsockoptTimeval(fd, level, opt int) (*Timeval, error) {
-	var tv Timeval
-	vallen := _Socklen(unsafe.Sizeof(tv))
-	err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen)
-	return &tv, err
-}
-
-func GetsockoptUint64(fd, level, opt int) (value uint64, err error) {
-	var n uint64
-	vallen := _Socklen(8)
-	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
-	return n, err
-}
-
-func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {
-	var rsa RawSockaddrAny
-	var len _Socklen = SizeofSockaddrAny
-	if n, err = recvfrom(fd, p, flags, &rsa, &len); err != nil {
-		return
-	}
-	if rsa.Addr.Family != AF_UNSPEC {
-		from, err = anyToSockaddr(fd, &rsa)
-	}
-	return
-}
-
-func Sendto(fd int, p []byte, flags int, to Sockaddr) (err error) {
-	ptr, n, err := to.sockaddr()
-	if err != nil {
-		return err
-	}
-	return sendto(fd, p, flags, ptr, n)
-}
-
-func SetsockoptByte(fd, level, opt int, value byte) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
-}
-
-func SetsockoptInt(fd, level, opt int, value int) (err error) {
-	var n = int32(value)
-	return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
-}
-
-func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
-}
-
-func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
-}
-
-func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
-}
-
-func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error {
-	return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
-}
-
-func SetsockoptLinger(fd, level, opt int, l *Linger) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
-}
-
-func SetsockoptString(fd, level, opt int, s string) (err error) {
-	var p unsafe.Pointer
-	if len(s) > 0 {
-		p = unsafe.Pointer(&[]byte(s)[0])
-	}
-	return setsockopt(fd, level, opt, p, uintptr(len(s)))
-}
-
-func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
-}
-
-func SetsockoptUint64(fd, level, opt int, value uint64) (err error) {
-	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8)
-}
-
-func Socket(domain, typ, proto int) (fd int, err error) {
-	if domain == AF_INET6 && SocketDisableIPv6 {
-		return -1, EAFNOSUPPORT
-	}
-	fd, err = socket(domain, typ, proto)
-	return
-}
-
-func Socketpair(domain, typ, proto int) (fd [2]int, err error) {
-	var fdx [2]int32
-	err = socketpair(domain, typ, proto, &fdx)
-	if err == nil {
-		fd[0] = int(fdx[0])
-		fd[1] = int(fdx[1])
-	}
-	return
-}
-
-var ioSync int64
-
-func CloseOnExec(fd int) { fcntl(fd, F_SETFD, FD_CLOEXEC) }
-
-func SetNonblock(fd int, nonblocking bool) (err error) {
-	flag, err := fcntl(fd, F_GETFL, 0)
-	if err != nil {
-		return err
-	}
-	if nonblocking {
-		flag |= O_NONBLOCK
-	} else {
-		flag &= ^O_NONBLOCK
-	}
-	_, err = fcntl(fd, F_SETFL, flag)
-	return err
-}
-
-// Exec calls execve(2), which replaces the calling executable in the process
-// tree. argv0 should be the full path to an executable ("/bin/ls") and the
-// executable name should also be the first argument in argv (["ls", "-l"]).
-// envv are the environment variables that should be passed to the new
-// process (["USER=go", "PWD=/tmp"]).
-func Exec(argv0 string, argv []string, envv []string) error {
-	return syscall.Exec(argv0, argv, envv)
-}
-
-func Getag(path string) (ccsid uint16, flag uint16, err error) {
-	var val [8]byte
-	sz, err := Getxattr(path, "ccsid", val[:])
-	if err != nil {
-		return
-	}
-	ccsid = uint16(EncodeData(val[0:sz]))
-	sz, err = Getxattr(path, "flags", val[:])
-	if err != nil {
-		return
-	}
-	flag = uint16(EncodeData(val[0:sz]) >> 15)
-	return
-}
-
-// Mount begin
-func impl_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(source)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(target)
-	if err != nil {
-		return
-	}
-	var _p2 *byte
-	_p2, err = BytePtrFromString(fstype)
-	if err != nil {
-		return
-	}
-	var _p3 *byte
-	_p3, err = BytePtrFromString(data)
-	if err != nil {
-		return
-	}
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MOUNT1_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(_p3)))
-	runtime.ExitSyscall()
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_MountAddr() *(func(source string, target string, fstype string, flags uintptr, data string) (err error))
-
-var Mount = enter_Mount
-
-func enter_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
-	funcref := get_MountAddr()
-	if validMount() {
-		*funcref = impl_Mount
-	} else {
-		*funcref = legacyMount
-	}
-	return (*funcref)(source, target, fstype, flags, data)
-}
-
-func legacyMount(source string, target string, fstype string, flags uintptr, data string) (err error) {
-	if needspace := 8 - len(fstype); needspace <= 0 {
-		fstype = fstype[0:8]
-	} else {
-		fstype += "        "[0:needspace]
-	}
-	return mount_LE(target, source, fstype, uint32(flags), int32(len(data)), data)
-}
-
-func validMount() bool {
-	if funcptrtest(GetZosLibVec()+SYS___MOUNT1_A<<4, "") == 0 {
-		if name, err := getLeFuncName(GetZosLibVec() + SYS___MOUNT1_A<<4); err == nil {
-			return name == "__mount1_a"
-		}
-	}
-	return false
-}
-
-// Mount end
-
-// Unmount begin
-func impl_Unmount(target string, flags int) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(target)
-	if err != nil {
-		return
-	}
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UMOUNT2_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(flags))
-	runtime.ExitSyscall()
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_UnmountAddr() *(func(target string, flags int) (err error))
-
-var Unmount = enter_Unmount
-
-func enter_Unmount(target string, flags int) (err error) {
-	funcref := get_UnmountAddr()
-	if funcptrtest(GetZosLibVec()+SYS___UMOUNT2_A<<4, "") == 0 {
-		*funcref = impl_Unmount
-	} else {
-		*funcref = legacyUnmount
-	}
-	return (*funcref)(target, flags)
-}
-
-func legacyUnmount(name string, mtm int) (err error) {
-	// mountpoint is always a full path and starts with a '/'
-	// check if input string is not a mountpoint but a filesystem name
-	if name[0] != '/' {
-		return unmount_LE(name, mtm)
-	}
-	// treat name as mountpoint
-	b2s := func(arr []byte) string {
-		var str string
-		for i := 0; i < len(arr); i++ {
-			if arr[i] == 0 {
-				str = string(arr[:i])
-				break
-			}
-		}
-		return str
-	}
-	var buffer struct {
-		header W_Mnth
-		fsinfo [64]W_Mntent
-	}
-	fs_count, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer)))
-	if err == nil {
-		err = EINVAL
-		for i := 0; i < fs_count; i++ {
-			if b2s(buffer.fsinfo[i].Mountpoint[:]) == name {
-				err = unmount_LE(b2s(buffer.fsinfo[i].Fsname[:]), mtm)
-				break
-			}
-		}
-	} else if fs_count == 0 {
-		err = EINVAL
-	}
-	return err
-}
-
-// Unmount end
-
-func direntIno(buf []byte) (uint64, bool) {
-	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
-}
-
-func direntReclen(buf []byte) (uint64, bool) {
-	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
-}
-
-func direntNamlen(buf []byte) (uint64, bool) {
-	reclen, ok := direntReclen(buf)
-	if !ok {
-		return 0, false
-	}
-	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
-}
-
-func direntLeToDirentUnix(dirent *direntLE, dir uintptr, path string) (Dirent, error) {
-	var d Dirent
-
-	d.Ino = uint64(dirent.Ino)
-	offset, err := Telldir(dir)
-	if err != nil {
-		return d, err
-	}
-
-	d.Off = int64(offset)
-	s := string(bytes.Split(dirent.Name[:], []byte{0})[0])
-	copy(d.Name[:], s)
-
-	d.Reclen = uint16(24 + len(d.NameString()))
-	var st Stat_t
-	path = path + "/" + s
-	err = Lstat(path, &st)
-	if err != nil {
-		return d, err
-	}
-
-	d.Type = uint8(st.Mode >> 24)
-	return d, err
-}
-
-func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
-	// Simulation of Getdirentries port from the Darwin implementation.
-	// COMMENTS FROM DARWIN:
-	// It's not the full required semantics, but should handle the case
-	// of calling Getdirentries or ReadDirent repeatedly.
-	// It won't handle assigning the results of lseek to *basep, or handle
-	// the directory being edited underfoot.
-
-	skip, err := Seek(fd, 0, 1 /* SEEK_CUR */)
-	if err != nil {
-		return 0, err
-	}
-
-	// Get path from fd to avoid unavailable call (fdopendir)
-	path, err := ZosFdToPath(fd)
-	if err != nil {
-		return 0, err
-	}
-	d, err := Opendir(path)
-	if err != nil {
-		return 0, err
-	}
-	defer Closedir(d)
-
-	var cnt int64
-	for {
-		var entryLE direntLE
-		var entrypLE *direntLE
-		e := Readdir_r(d, &entryLE, &entrypLE)
-		if e != nil {
-			return n, e
-		}
-		if entrypLE == nil {
-			break
-		}
-		if skip > 0 {
-			skip--
-			cnt++
-			continue
-		}
-
-		// Dirent on zos has a different structure
-		entry, e := direntLeToDirentUnix(&entryLE, d, path)
-		if e != nil {
-			return n, e
-		}
-
-		reclen := int(entry.Reclen)
-		if reclen > len(buf) {
-			// Not enough room. Return for now.
-			// The counter will let us know where we should start up again.
-			// Note: this strategy for suspending in the middle and
-			// restarting is O(n^2) in the length of the directory. Oh well.
-			break
-		}
-
-		// Copy entry into return buffer.
-		s := unsafe.Slice((*byte)(unsafe.Pointer(&entry)), reclen)
-		copy(buf, s)
-
-		buf = buf[reclen:]
-		n += reclen
-		cnt++
-	}
-	// Set the seek offset of the input fd to record
-	// how many files we've already returned.
-	_, err = Seek(fd, cnt, 0 /* SEEK_SET */)
-	if err != nil {
-		return n, err
-	}
-
-	return n, nil
-}
-
-func Err2ad() (eadd *int) {
-	r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS___ERR2AD<<4)
-	eadd = (*int)(unsafe.Pointer(r0))
-	return
-}
-
-func ZosConsolePrintf(format string, v ...interface{}) (int, error) {
-	type __cmsg struct {
-		_            uint16
-		_            [2]uint8
-		__msg_length uint32
-		__msg        uintptr
-		_            [4]uint8
-	}
-	msg := fmt.Sprintf(format, v...)
-	strptr := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&msg)).Data)
-	len := (*reflect.StringHeader)(unsafe.Pointer(&msg)).Len
-	cmsg := __cmsg{__msg_length: uint32(len), __msg: uintptr(strptr)}
-	cmd := uint32(0)
-	runtime.EnterSyscall()
-	rc, err2, err1 := CallLeFuncWithErr(GetZosLibVec()+SYS_____CONSOLE_A<<4, uintptr(unsafe.Pointer(&cmsg)), 0, uintptr(unsafe.Pointer(&cmd)))
-	runtime.ExitSyscall()
-	if rc != 0 {
-		return 0, fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2)
-	}
-	return 0, nil
-}
-func ZosStringToEbcdicBytes(str string, nullterm bool) (ebcdicBytes []byte) {
-	if nullterm {
-		ebcdicBytes = []byte(str + "\x00")
-	} else {
-		ebcdicBytes = []byte(str)
-	}
-	A2e(ebcdicBytes)
-	return
-}
-func ZosEbcdicBytesToString(b []byte, trimRight bool) (str string) {
-	res := make([]byte, len(b))
-	copy(res, b)
-	E2a(res)
-	if trimRight {
-		str = string(bytes.TrimRight(res, " \x00"))
-	} else {
-		str = string(res)
-	}
-	return
-}
-
-func fdToPath(dirfd int) (path string, err error) {
-	var buffer [1024]byte
-	// w_ctrl()
-	ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_W_IOCTL<<4,
-		[]uintptr{uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))})
-	if ret == 0 {
-		zb := bytes.IndexByte(buffer[:], 0)
-		if zb == -1 {
-			zb = len(buffer)
-		}
-		// __e2a_l()
-		runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4,
-			[]uintptr{uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)})
-		return string(buffer[:zb]), nil
-	}
-	// __errno()
-	errno := int(*(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4,
-		[]uintptr{}))))
-	// __errno2()
-	errno2 := int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO2<<4,
-		[]uintptr{}))
-	// strerror_r()
-	ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_STRERROR_R<<4,
-		[]uintptr{uintptr(errno), uintptr(unsafe.Pointer(&buffer[0])), 1024})
-	if ret == 0 {
-		zb := bytes.IndexByte(buffer[:], 0)
-		if zb == -1 {
-			zb = len(buffer)
-		}
-		return "", fmt.Errorf("%s (errno2=0x%x)", buffer[:zb], errno2)
-	} else {
-		return "", fmt.Errorf("fdToPath errno %d (errno2=0x%x)", errno, errno2)
-	}
-}
-
-func impl_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(path)
-	if err != nil {
-		return
-	}
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKFIFOAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
-	runtime.ExitSyscall()
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-//go:nosplit
-func get_MkfifoatAddr() *(func(dirfd int, path string, mode uint32) (err error))
-
-var Mkfifoat = enter_Mkfifoat
-
-func enter_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
-	funcref := get_MkfifoatAddr()
-	if funcptrtest(GetZosLibVec()+SYS___MKFIFOAT_A<<4, "") == 0 {
-		*funcref = impl_Mkfifoat
-	} else {
-		*funcref = legacy_Mkfifoat
-	}
-	return (*funcref)(dirfd, path, mode)
-}
-
-func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) {
-	dirname, err := ZosFdToPath(dirfd)
-	if err != nil {
-		return err
-	}
-	return Mkfifo(dirname+"/"+path, mode)
-}
-
-//sys	Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT
-//sys	Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT
-//sys	Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT
-
-func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) {
-	runtime.EnterSyscall()
-	r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg)
-	runtime.ExitSyscall()
-	val = int(r0)
-	if int64(r0) == -1 {
-		err = errnoErr2(e1, e2)
-	}
-	return
-}
-
-func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) {
-	switch op.(type) {
-	case *Flock_t:
-		err = FcntlFlock(fd, cmd, op.(*Flock_t))
-		if err != nil {
-			ret = -1
-		}
-		return
-	case int:
-		return FcntlInt(fd, cmd, op.(int))
-	case *F_cnvrt:
-		return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt))))
-	case unsafe.Pointer:
-		return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer)))
-	default:
-		return -1, EINVAL
-	}
-	return
-}
-
-func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
-	if raceenabled {
-		raceReleaseMerge(unsafe.Pointer(&ioSync))
-	}
-	return sendfile(outfd, infd, offset, count)
-}
-
-func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
-	// TODO: use LE call instead if the call is implemented
-	originalOffset, err := Seek(infd, 0, SEEK_CUR)
-	if err != nil {
-		return -1, err
-	}
-	//start reading data from in_fd
-	if offset != nil {
-		_, err := Seek(infd, *offset, SEEK_SET)
-		if err != nil {
-			return -1, err
-		}
-	}
-
-	buf := make([]byte, count)
-	readBuf := make([]byte, 0)
-	var n int = 0
-	for i := 0; i < count; i += n {
-		n, err := Read(infd, buf)
-		if n == 0 {
-			if err != nil {
-				return -1, err
-			} else { // EOF
-				break
-			}
-		}
-		readBuf = append(readBuf, buf...)
-		buf = buf[0:0]
-	}
-
-	n2, err := Write(outfd, readBuf)
-	if err != nil {
-		return -1, err
-	}
-
-	//When sendfile() returns, this variable will be set to the
-	// offset of the byte following the last byte that was read.
-	if offset != nil {
-		*offset = *offset + int64(n)
-		// If offset is not NULL, then sendfile() does not modify the file
-		// offset of in_fd
-		_, err := Seek(infd, originalOffset, SEEK_SET)
-		if err != nil {
-			return -1, err
-		}
-	}
-	return n2, nil
-}