mirror of
https://github.com/golang/go
synced 2024-10-06 03:21:27 -06:00
451667a67f
Recent crashes on 386 Darwin appear to be caused by this system call smashing the stack. Phenomenology shows that allocating more data here addresses the probem. The guess is that since the actual system call is getdirentries64, 64 is what we should allocate. Should fix the darwin/386 build. R=rsc CC=golang-codereviews https://golang.org/cl/53840043
546 lines
14 KiB
Go
546 lines
14 KiB
Go
// Copyright 2009 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.
|
|
|
|
// +build darwin dragonfly freebsd netbsd openbsd
|
|
|
|
// BSD system call wrappers shared by *BSD based systems
|
|
// including OS X (Darwin) and FreeBSD. Like the other
|
|
// syscall_*.go files it is compiled as Go code but also
|
|
// used as input to mksyscall which parses the //sys
|
|
// lines and generates system call stubs.
|
|
|
|
package syscall
|
|
|
|
import (
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
/*
|
|
* Wrapped
|
|
*/
|
|
|
|
//sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error)
|
|
//sysnb setgroups(ngid int, gid *_Gid_t) (err error)
|
|
|
|
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 16 on BSD.
|
|
if n < 0 || n > 1000 {
|
|
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 ReadDirent(fd int, buf []byte) (n int, err error) {
|
|
// Final argument is (basep *uintptr) and the syscall doesn't take nil.
|
|
// 64 bits should be enough. (32 bits isn't even on 386). Since the
|
|
// actual system call is getdirentries64, 64 is a good guess.
|
|
// TODO(rsc): Can we use a single global basep for all calls?
|
|
var base = (*uintptr)(unsafe.Pointer(new(uint64)))
|
|
return Getdirentries(fd, buf, base)
|
|
}
|
|
|
|
// 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.
|
|
|
|
type WaitStatus uint32
|
|
|
|
const (
|
|
mask = 0x7F
|
|
core = 0x80
|
|
shift = 8
|
|
|
|
exited = 0
|
|
stopped = 0x7F
|
|
)
|
|
|
|
func (w WaitStatus) Exited() bool { return w&mask == exited }
|
|
|
|
func (w WaitStatus) ExitStatus() int {
|
|
if w&mask != exited {
|
|
return -1
|
|
}
|
|
return int(w >> shift)
|
|
}
|
|
|
|
func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
|
|
|
|
func (w WaitStatus) Signal() Signal {
|
|
sig := Signal(w & mask)
|
|
if sig == stopped || sig == 0 {
|
|
return -1
|
|
}
|
|
return sig
|
|
}
|
|
|
|
func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
|
|
|
|
func (w WaitStatus) Stopped() bool { return w&mask == stopped && Signal(w>>shift) != SIGSTOP }
|
|
|
|
func (w WaitStatus) Continued() bool { return w&mask == stopped && Signal(w>>shift) == SIGSTOP }
|
|
|
|
func (w WaitStatus) StopSignal() Signal {
|
|
if !w.Stopped() {
|
|
return -1
|
|
}
|
|
return Signal(w>>shift) & 0xFF
|
|
}
|
|
|
|
func (w WaitStatus) TrapCause() int { return -1 }
|
|
|
|
//sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)
|
|
|
|
func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
|
|
var status _C_int
|
|
wpid, err = wait4(pid, &status, options, rusage)
|
|
if wstatus != nil {
|
|
*wstatus = WaitStatus(status)
|
|
}
|
|
return
|
|
}
|
|
|
|
//sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
|
|
//sys bind(s int, addr uintptr, addrlen _Socklen) (err error)
|
|
//sys connect(s int, addr uintptr, addrlen _Socklen) (err error)
|
|
//sysnb socket(domain int, typ int, proto int) (fd int, err error)
|
|
//sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error)
|
|
//sys setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error)
|
|
//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
|
|
//sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
|
|
//sys Shutdown(s int, how int) (err error)
|
|
|
|
func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, error) {
|
|
if sa.Port < 0 || sa.Port > 0xFFFF {
|
|
return 0, 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 uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil
|
|
}
|
|
|
|
func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, error) {
|
|
if sa.Port < 0 || sa.Port > 0xFFFF {
|
|
return 0, 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 uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil
|
|
}
|
|
|
|
func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, error) {
|
|
name := sa.Name
|
|
n := len(name)
|
|
if n >= len(sa.raw.Path) || n == 0 {
|
|
return 0, 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 uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil
|
|
}
|
|
|
|
func (sa *SockaddrDatalink) sockaddr() (uintptr, _Socklen, error) {
|
|
if sa.Index == 0 {
|
|
return 0, 0, EINVAL
|
|
}
|
|
sa.raw.Len = sa.Len
|
|
sa.raw.Family = AF_LINK
|
|
sa.raw.Index = sa.Index
|
|
sa.raw.Type = sa.Type
|
|
sa.raw.Nlen = sa.Nlen
|
|
sa.raw.Alen = sa.Alen
|
|
sa.raw.Slen = sa.Slen
|
|
for i := 0; i < len(sa.raw.Data); i++ {
|
|
sa.raw.Data[i] = sa.Data[i]
|
|
}
|
|
return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrDatalink, nil
|
|
}
|
|
|
|
func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
|
|
switch rsa.Addr.Family {
|
|
case AF_LINK:
|
|
pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa))
|
|
sa := new(SockaddrDatalink)
|
|
sa.Len = pp.Len
|
|
sa.Family = pp.Family
|
|
sa.Index = pp.Index
|
|
sa.Type = pp.Type
|
|
sa.Nlen = pp.Nlen
|
|
sa.Alen = pp.Alen
|
|
sa.Slen = pp.Slen
|
|
for i := 0; i < len(sa.Data); i++ {
|
|
sa.Data[i] = pp.Data[i]
|
|
}
|
|
return sa, nil
|
|
|
|
case AF_UNIX:
|
|
pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
|
|
if pp.Len < 2 || pp.Len > SizeofSockaddrUnix {
|
|
return nil, EINVAL
|
|
}
|
|
sa := new(SockaddrUnix)
|
|
|
|
// Some BSDs include the trailing NUL in the length, whereas
|
|
// others do not. Work around this by subtracting the leading
|
|
// family and len. The path is then scanned to see if a NUL
|
|
// terminator still exists within the length.
|
|
n := int(pp.Len) - 2 // subtract leading Family, Len
|
|
for i := 0; i < n; i++ {
|
|
if pp.Path[i] == 0 {
|
|
// found early NUL; assume Len included the NUL
|
|
// or was overestimating.
|
|
n = i
|
|
break
|
|
}
|
|
}
|
|
bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
|
|
sa.Name = string(bytes)
|
|
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
|
|
}
|
|
if runtime.GOOS == "darwin" && len == 0 {
|
|
// Accepted socket has no address.
|
|
// This is likely due to a bug in xnu kernels,
|
|
// where instead of ECONNABORTED error socket
|
|
// is accepted, but has no address.
|
|
Close(nfd)
|
|
return 0, nil, ECONNABORTED
|
|
}
|
|
sa, err = anyToSockaddr(&rsa)
|
|
if err != nil {
|
|
Close(nfd)
|
|
nfd = 0
|
|
}
|
|
return
|
|
}
|
|
|
|
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(jsing): DragonFly has a "bug" (see issue 3349), which should be
|
|
// reported upstream.
|
|
if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 {
|
|
rsa.Addr.Family = AF_UNIX
|
|
rsa.Addr.Len = SizeofSockaddrUnix
|
|
}
|
|
return anyToSockaddr(&rsa)
|
|
}
|
|
|
|
//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
|
|
|
|
func GetsockoptByte(fd, level, opt int) (value byte, err error) {
|
|
var n byte
|
|
vallen := _Socklen(1)
|
|
err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), &vallen)
|
|
return n, err
|
|
}
|
|
|
|
func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
|
|
vallen := _Socklen(4)
|
|
err = getsockopt(fd, level, opt, uintptr(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, uintptr(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, uintptr(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, uintptr(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, uintptr(unsafe.Pointer(&value)), &vallen)
|
|
return &value, err
|
|
}
|
|
|
|
//sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
|
|
//sys sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error)
|
|
//sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
|
|
|
|
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 = uint32(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 {
|
|
from, err = anyToSockaddr(&rsa)
|
|
}
|
|
return
|
|
}
|
|
|
|
//sys sendmsg(s int, msg *Msghdr, flags int) (err error)
|
|
|
|
func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
|
|
var ptr uintptr
|
|
var salen _Socklen
|
|
if to != nil {
|
|
ptr, salen, err = to.sockaddr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
var msg Msghdr
|
|
msg.Name = (*byte)(unsafe.Pointer(ptr))
|
|
msg.Namelen = uint32(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 err = sendmsg(fd, &msg, flags); err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
//sys kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error)
|
|
|
|
func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) {
|
|
var change, event uintptr
|
|
if len(changes) > 0 {
|
|
change = uintptr(unsafe.Pointer(&changes[0]))
|
|
}
|
|
if len(events) > 0 {
|
|
event = uintptr(unsafe.Pointer(&events[0]))
|
|
}
|
|
return kevent(kq, change, len(changes), event, len(events), timeout)
|
|
}
|
|
|
|
//sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
|
|
|
|
func Sysctl(name string) (value string, err error) {
|
|
// Translate name to mib number.
|
|
mib, err := nametomib(name)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Find size.
|
|
n := uintptr(0)
|
|
if err = sysctl(mib, nil, &n, nil, 0); err != nil {
|
|
return "", err
|
|
}
|
|
if n == 0 {
|
|
return "", nil
|
|
}
|
|
|
|
// Read into buffer of that size.
|
|
buf := make([]byte, n)
|
|
if err = sysctl(mib, &buf[0], &n, nil, 0); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Throw away terminating NUL.
|
|
if n > 0 && buf[n-1] == '\x00' {
|
|
n--
|
|
}
|
|
return string(buf[0:n]), nil
|
|
}
|
|
|
|
func SysctlUint32(name string) (value uint32, err error) {
|
|
// Translate name to mib number.
|
|
mib, err := nametomib(name)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
// Read into buffer of that size.
|
|
n := uintptr(4)
|
|
buf := make([]byte, 4)
|
|
if err = sysctl(mib, &buf[0], &n, nil, 0); err != nil {
|
|
return 0, err
|
|
}
|
|
if n != 4 {
|
|
return 0, EIO
|
|
}
|
|
return *(*uint32)(unsafe.Pointer(&buf[0])), nil
|
|
}
|
|
|
|
//sys utimes(path string, timeval *[2]Timeval) (err error)
|
|
func Utimes(path string, tv []Timeval) (err error) {
|
|
if len(tv) != 2 {
|
|
return EINVAL
|
|
}
|
|
return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
|
|
}
|
|
|
|
func UtimesNano(path string, ts []Timespec) error {
|
|
// TODO: The BSDs can do utimensat with SYS_UTIMENSAT but it
|
|
// isn't supported by darwin so this uses utimes instead
|
|
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])))
|
|
}
|
|
|
|
//sys futimes(fd int, timeval *[2]Timeval) (err error)
|
|
func Futimes(fd int, tv []Timeval) (err error) {
|
|
if len(tv) != 2 {
|
|
return EINVAL
|
|
}
|
|
return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
|
|
}
|
|
|
|
//sys fcntl(fd int, cmd int, arg int) (val int, err error)
|
|
|
|
// TODO: wrap
|
|
// Acct(name nil-string) (err error)
|
|
// Gethostuuid(uuid *byte, timeout *Timespec) (err error)
|
|
// Madvise(addr *byte, len int, behav int) (err error)
|
|
// Mprotect(addr *byte, len int, prot int) (err error)
|
|
// Msync(addr *byte, len int, flags int) (err error)
|
|
// Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error)
|
|
|
|
var mapper = &mmapper{
|
|
active: make(map[*byte][]byte),
|
|
mmap: mmap,
|
|
munmap: munmap,
|
|
}
|
|
|
|
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)
|
|
}
|