2009-06-01 23:14:57 -06:00
|
|
|
// 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.
|
|
|
|
|
2013-08-23 09:51:25 -06:00
|
|
|
// +build darwin dragonfly freebsd linux netbsd openbsd
|
build: add build comments to core packages
The go/build package already recognizes
system-specific file names like
mycode_darwin.go
mycode_darwin_386.go
mycode_386.s
However, it is also common to write files that
apply to multiple architectures, so a recent CL added
to go/build the ability to process comments
listing a set of conditions for building. For example:
// +build darwin freebsd openbsd/386
says that this file should be compiled only on
OS X, FreeBSD, or 32-bit x86 OpenBSD systems.
These conventions are not yet documented
(hence this long CL description).
This CL adds build comments to the multi-system
files in the core library, a step toward making it
possible to use go/build to build them.
With this change go/build can handle crypto/rand,
exec, net, path/filepath, os/user, and time.
os and syscall need additional adjustments.
R=golang-dev, r, gri, r, gustavo
CC=golang-dev
https://golang.org/cl/5011046
2011-09-15 14:48:57 -06:00
|
|
|
|
2009-06-01 23:14:57 -06:00
|
|
|
package syscall
|
|
|
|
|
2011-06-14 09:29:51 -06:00
|
|
|
import (
|
2012-01-13 14:40:55 -07:00
|
|
|
"runtime"
|
2011-06-14 09:29:51 -06:00
|
|
|
"sync"
|
|
|
|
"unsafe"
|
|
|
|
)
|
|
|
|
|
2010-04-02 02:11:17 -06:00
|
|
|
var (
|
|
|
|
Stdin = 0
|
|
|
|
Stdout = 1
|
|
|
|
Stderr = 2
|
|
|
|
)
|
|
|
|
|
2012-01-13 14:40:55 -07:00
|
|
|
const darwinAMD64 = runtime.GOOS == "darwin" && runtime.GOARCH == "amd64"
|
2011-06-20 16:40:20 -06:00
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
|
|
|
|
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
|
|
|
|
func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
|
|
|
|
func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
|
2011-06-14 09:29:51 -06:00
|
|
|
|
|
|
|
// 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
|
2011-11-13 20:44:52 -07:00
|
|
|
mmap func(addr, length uintptr, prot, flags, fd int, offset int64) (uintptr, error)
|
|
|
|
munmap func(addr uintptr, length uintptr) error
|
2011-06-14 09:29:51 -06:00
|
|
|
}
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
|
2011-06-14 09:29:51 -06:00
|
|
|
if length <= 0 {
|
|
|
|
return nil, EINVAL
|
|
|
|
}
|
|
|
|
|
|
|
|
// Map the requested memory.
|
|
|
|
addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset)
|
2011-11-13 20:44:52 -07:00
|
|
|
if errno != nil {
|
2011-06-14 09:29:51 -06:00
|
|
|
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
|
2011-11-13 20:44:52 -07:00
|
|
|
return b, nil
|
2011-06-14 09:29:51 -06:00
|
|
|
}
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func (m *mmapper) Munmap(data []byte) (err error) {
|
2011-06-14 09:29:51 -06:00
|
|
|
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.
|
2011-11-13 20:44:52 -07:00
|
|
|
if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
|
2011-06-14 09:29:51 -06:00
|
|
|
return errno
|
|
|
|
}
|
2011-10-18 07:56:34 -06:00
|
|
|
delete(m.active, p)
|
2011-11-13 20:44:52 -07:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// An Errno is an unsigned number describing an error condition.
|
|
|
|
// It implements the error interface. The zero Errno is by convention
|
|
|
|
// a non-error, so code to convert from Errno to error should use:
|
|
|
|
// err = nil
|
|
|
|
// if errno != 0 {
|
|
|
|
// err = errno
|
|
|
|
// }
|
|
|
|
type Errno uintptr
|
|
|
|
|
|
|
|
func (e Errno) Error() string {
|
2012-02-16 13:23:50 -07:00
|
|
|
if 0 <= int(e) && int(e) < len(errors) {
|
2011-11-13 20:44:52 -07:00
|
|
|
s := errors[e]
|
|
|
|
if s != "" {
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "errno " + itoa(int(e))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Errno) Temporary() bool {
|
|
|
|
return e == EINTR || e == EMFILE || e.Timeout()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Errno) Timeout() bool {
|
|
|
|
return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
|
2011-06-14 09:29:51 -06:00
|
|
|
}
|
os/signal: selective signal handling
Restore package os/signal, with new API:
Notify replaces Incoming, allowing clients
to ask for certain signals only. Also, signals
go to everyone who asks, not just one client.
This could plausibly move into package os now
that there are no magic side effects as a result
of the import.
Update runtime for new API: move common Unix
signal handling code into signal_unix.c.
(It's so easy to do this now that we don't have
to edit Makefiles!)
Tested on darwin,linux 386,amd64.
Fixes #1266.
R=r, dsymonds, bradfitz, iant, borman
CC=golang-dev
https://golang.org/cl/3749041
2012-02-13 11:52:37 -07:00
|
|
|
|
|
|
|
// A Signal is a number describing a process signal.
|
|
|
|
// It implements the os.Signal interface.
|
|
|
|
type Signal int
|
|
|
|
|
|
|
|
func (s Signal) Signal() {}
|
|
|
|
|
|
|
|
func (s Signal) String() string {
|
|
|
|
if 0 <= s && int(s) < len(signals) {
|
|
|
|
str := signals[s]
|
|
|
|
if str != "" {
|
|
|
|
return str
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "signal " + itoa(int(s))
|
|
|
|
}
|
2012-10-09 10:51:58 -06:00
|
|
|
|
|
|
|
func Read(fd int, p []byte) (n int, err error) {
|
|
|
|
n, err = read(fd, p)
|
2013-06-10 12:40:35 -06:00
|
|
|
if raceenabled {
|
|
|
|
if n > 0 {
|
|
|
|
raceWriteRange(unsafe.Pointer(&p[0]), n)
|
|
|
|
}
|
|
|
|
if err == nil {
|
|
|
|
raceAcquire(unsafe.Pointer(&ioSync))
|
|
|
|
}
|
2012-10-09 10:51:58 -06:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func Write(fd int, p []byte) (n int, err error) {
|
|
|
|
if raceenabled {
|
|
|
|
raceReleaseMerge(unsafe.Pointer(&ioSync))
|
|
|
|
}
|
2013-06-10 12:40:35 -06:00
|
|
|
n, err = write(fd, p)
|
|
|
|
if raceenabled && n > 0 {
|
|
|
|
raceReadRange(unsafe.Pointer(&p[0]), n)
|
|
|
|
}
|
|
|
|
return
|
2012-10-09 10:51:58 -06:00
|
|
|
}
|
|
|
|
|
2013-06-21 19:03:40 -06:00
|
|
|
// For testing: clients can set this flag to force
|
|
|
|
// creation of IPv6 sockets to return EAFNOSUPPORT.
|
|
|
|
var SocketDisableIPv6 bool
|
|
|
|
|
|
|
|
type Sockaddr interface {
|
|
|
|
sockaddr() (ptr uintptr, len _Socklen, err error) // lowercase; only we can define Sockaddrs
|
|
|
|
}
|
|
|
|
|
|
|
|
type SockaddrInet4 struct {
|
|
|
|
Port int
|
|
|
|
Addr [4]byte
|
|
|
|
raw RawSockaddrInet4
|
|
|
|
}
|
|
|
|
|
|
|
|
type SockaddrInet6 struct {
|
|
|
|
Port int
|
|
|
|
ZoneId uint32
|
|
|
|
Addr [16]byte
|
|
|
|
raw RawSockaddrInet6
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2013-06-24 18:14:40 -06:00
|
|
|
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(&rsa)
|
|
|
|
}
|
|
|
|
|
|
|
|
func GetsockoptInt(fd, level, opt int) (value int, err error) {
|
|
|
|
var n int32
|
|
|
|
vallen := _Socklen(4)
|
|
|
|
err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), &vallen)
|
|
|
|
return int(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(&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)
|
|
|
|
}
|
|
|
|
|
2013-07-04 21:25:23 -06:00
|
|
|
func SetsockoptByte(fd, level, opt int, value byte) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptInt(fd, level, opt int, value int) (err error) {
|
|
|
|
var n = int32(value)
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), 4)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value[0])), 4)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), SizeofIPMreq)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), SizeofIPv6Mreq)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(filter)), SizeofICMPv6Filter)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptLinger(fd, level, opt int, l *Linger) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(l)), SizeofLinger)
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptString(fd, level, opt int, s string) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&[]byte(s)[0])), uintptr(len(s)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (err error) {
|
|
|
|
return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(tv)), unsafe.Sizeof(*tv))
|
|
|
|
}
|
|
|
|
|
2013-06-21 19:03:40 -06:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2012-10-29 13:15:06 -06:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
var ioSync int64
|