path: root/Godeps/_workspace/src/golang.org/x/sys/unix/syscall_solaris.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.

// Solaris system calls.
// This file is compiled as ordinary Go code,
// but it is also input to mksyscall,
// which parses the //sys lines and generates system call stubs.
// Note that sometimes we use a lowercase //sys name and wrap
// it in our own nicer implementation, either here or in
// syscall_solaris.go or syscall_unix.go.

package unix

import (
    "sync/atomic"
    "syscall"
    "unsafe"
)

// Implemented in runtime/syscall_solaris.go.
type syscallFunc uintptr

func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)

type SockaddrDatalink struct {
    Family uint16
    Index  uint16
    Type   uint8
    Nlen   uint8
    Alen   uint8
    Slen   uint8
    Data   [244]int8
    raw    RawSockaddrDatalink
}

func clen(n []byte) int {
    for i := 0; i < len(n); i++ {
        if n[i] == 0 {
            return i
        }
    }
    return len(n)
}

// ParseDirent parses up to max directory entries in buf,
// appending the names to names.  It returns the number
// bytes consumed from buf, the number of entries added
// to names, and the new names slice.
func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
    origlen := len(buf)
    for max != 0 && len(buf) > 0 {
        dirent := (*Dirent)(unsafe.Pointer(&buf[0]))
        if dirent.Reclen == 0 {
            buf = nil
            break
        }
        buf = buf[dirent.Reclen:]
        if dirent.Ino == 0 { // File absent in directory.
            continue
        }
        bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0]))
        var name = string(bytes[0:clen(bytes[:])])
        if name == "." || name == ".." { // Useless names
            continue
        }
        max--
        count++
        names = append(names, name)
    }
    return origlen - len(buf), count, names
}

func pipe() (r uintptr, w uintptr, err uintptr)

func Pipe(p []int) (err error) {
    if len(p) != 2 {
        return EINVAL
    }
    r0, w0, e1 := pipe()
    if e1 != 0 {
        err = syscall.Errno(e1)
    }
    p[0], p[1] = int(r0), int(w0)
    return
}

func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
    if sa.Port < 0 || sa.Port > 0xFFFF {
        return nil, 0, EINVAL
    }
    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), SizeofSockaddrInet4, nil
}

func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
    if sa.Port < 0 || sa.Port > 0xFFFF {
        return nil, 0, EINVAL
    }
    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), SizeofSockaddrInet6, nil
}

func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
    name := sa.Name
    n := len(name)
    if n >= len(sa.raw.Path) {
        return nil, 0, EINVAL
    }
    sa.raw.Family = AF_UNIX
    for i := 0; i < n; i++ {
        sa.raw.Path[i] = int8(name[i])
    }
    // length is family (uint16), name, NUL.
    sl := _Socklen(2)
    if n > 0 {
        sl += _Socklen(n) + 1
    }
    if sa.raw.Path[0] == '@' {
        sa.raw.Path[0] = 0
        // Don't count trailing NUL for abstract address.
        sl--
    }

    return unsafe.Pointer(&sa.raw), sl, nil
}

//sys   getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname

func Getsockname(fd int) (sa Sockaddr, err error) {
    var rsa RawSockaddrAny
    var len _Socklen = SizeofSockaddrAny
    if err = getsockname(fd, &rsa, &len); err != nil {
        return
    }
    return anyToSockaddr(&rsa)
}

const ImplementsGetwd = true

//sys   Getcwd(buf []byte) (n int, err error)

func Getwd() (wd string, err error) {
    var buf [PathMax]byte
    // Getcwd will return an error if it failed for any reason.
    _, err = Getcwd(buf[0:])
    if err != nil {
        return "", err
    }
    n := clen(buf[:])
    if n < 1 {
        return "", EINVAL
    }
    return string(buf[:n]), nil
}

/*
 * 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)
    // Check for error and sanity check group count.  Newer versions of
    // Solaris allow up to 1024 (NGROUPS_MAX).
    if n < 0 || n > 1024 {
        if err != nil {
            return nil, err
        }
        return nil, EINVAL
    } else if n == 0 {
        return nil, nil
    }

    a := make([]_Gid_t, n)
    n, err = getgroups(n, &a[0])
    if n == -1 {
        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.
    // TODO(rsc): Can we use a single global basep for all calls?
    return Getdents(fd, buf, new(uintptr))
}

// 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() syscall.Signal {
    sig := syscall.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 && syscall.Signal(w>>shift) != SIGSTOP }

func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }

func (w WaitStatus) StopSignal() syscall.Signal {
    if !w.Stopped() {
        return -1
    }
    return syscall.Signal(w>>shift) & 0xFF
}

func (w WaitStatus) TrapCause() int { return -1 }

func wait4(pid uintptr, wstatus *WaitStatus, options uintptr, rusage *Rusage) (wpid uintptr, err uintptr)

func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
    r0, e1 := wait4(uintptr(pid), wstatus, uintptr(options), rusage)
    if e1 != 0 {
        err = syscall.Errno(e1)
    }
    return int(r0), err
}

func gethostname() (name string, err uintptr)

func Gethostname() (name string, err error) {
    name, e1 := gethostname()
    if e1 != 0 {
        err = syscall.Errno(e1)
    }
    return name, err
}

//sys   utimes(path string, times *[2]Timeval) (err error)

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(fd int, path string, times *[2]Timespec, flag int) (err error)

func UtimesNano(path string, ts []Timespec) 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 UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) 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)
}

//sys   fcntl(fd int, cmd int, arg int) (val int, err error)

// 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 {
    _, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0)
    if e1 != 0 {
        return e1
    }
    return nil
}

//sys   futimesat(fildes int, path *byte, times *[2]Timeval) (err error)

func Futimesat(dirfd int, path string, tv []Timeval) error {
    pathp, err := BytePtrFromString(path)
    if err != nil {
        return err
    }
    if tv == nil {
        return futimesat(dirfd, pathp, nil)
    }
    if len(tv) != 2 {
        return EINVAL
    }
    return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
}

// Solaris doesn't have an futimes function because it allows NULL to be
// specified as the path for futimesat.  However, Go doesn't like
// NULL-style string interfaces, so this simple wrapper is provided.
func Futimes(fd int, tv []Timeval) error {
    if tv == nil {
        return futimesat(fd, nil, nil)
    }
    if len(tv) != 2 {
        return EINVAL
    }
    return futimesat(fd, nil, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
}

func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
    switch rsa.Addr.Family {
    case AF_UNIX:
        pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
        sa := new(SockaddrUnix)
        // Assume path ends at NUL.
        // This is not technically the Solaris 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 < len(pp.Path) && pp.Path[n] != 0 {
            n++
        }
        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
}

//sys   accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept

func Accept(fd int) (nfd int, sa Sockaddr, err error) {
    var rsa RawSockaddrAny
    var len _Socklen = SizeofSockaddrAny
    nfd, err = accept(fd, &rsa, &len)
    if nfd == -1 {
        return
    }
    sa, err = anyToSockaddr(&rsa)
    if err != nil {
        Close(nfd)
        nfd = 0
    }
    return
}

//sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.recvmsg

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 = (*int8)(unsafe.Pointer(&p[0]))
        iov.SetLen(len(p))
    }
    var dummy int8
    if len(oob) > 0 {
        // receive at least one normal byte
        if len(p) == 0 {
            iov.Base = &dummy
            iov.SetLen(1)
        }
        msg.Accrights = (*int8)(unsafe.Pointer(&oob[0]))
    }
    msg.Iov = &iov
    msg.Iovlen = 1
    if n, err = recvmsg(fd, &msg, flags); n == -1 {
        return
    }
    oobn = int(msg.Accrightslen)
    // source address is only specified if the socket is unconnected
    if rsa.Addr.Family != AF_UNSPEC {
        from, err = anyToSockaddr(&rsa)
    }
    return
}

func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
    _, err = SendmsgN(fd, p, oob, to, flags)
    return
}

//sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.sendmsg

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 {
        ptr, salen, err = to.sockaddr()
        if err != nil {
            return 0, err
        }
    }
    var msg Msghdr
    msg.Name = (*byte)(unsafe.Pointer(ptr))
    msg.Namelen = uint32(salen)
    var iov Iovec
    if len(p) > 0 {
        iov.Base = (*int8)(unsafe.Pointer(&p[0]))
        iov.SetLen(len(p))
    }
    var dummy int8
    if len(oob) > 0 {
        // send at least one normal byte
        if len(p) == 0 {
            iov.Base = &dummy
            iov.SetLen(1)
        }
        msg.Accrights = (*int8)(unsafe.Pointer(&oob[0]))
    }
    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
}

//sys   acct(path *byte) (err error)

func Acct(path string) (err error) {
    if len(path) == 0 {
        // Assume caller wants to disable accounting.
        return acct(nil)
    }

    pathp, err := BytePtrFromString(path)
    if err != nil {
        return err
    }
    return acct(pathp)
}

/*
 * Expose the ioctl function
 */

//sys   ioctl(fd int, req int, arg uintptr) (err error)

func IoctlSetInt(fd int, req int, value int) (err error) {
    return ioctl(fd, req, uintptr(value))
}

func IoctlSetWinsize(fd int, req int, value *Winsize) (err error) {
    return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
}

func IoctlSetTermios(fd int, req int, value *Termios) (err error) {
    return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
}

func IoctlSetTermio(fd int, req int, value *Termio) (err error) {
    return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
}

func IoctlGetInt(fd int, req int) (int, error) {
    var value int
    err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
    return value, err
}

func IoctlGetWinsize(fd int, req int) (*Winsize, error) {
    var value Winsize
    err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
    return &value, err
}

func IoctlGetTermios(fd int, req int) (*Termios, error) {
    var value Termios
    err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
    return &value, err
}

func IoctlGetTermio(fd int, req int) (*Termio, error) {
    var value Termio
    err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
    return &value, err
}

/*
 * Exposed directly
 */
//sys   Access(path string, mode uint32) (err error)
//sys   Adjtime(delta *Timeval, olddelta *Timeval) (err error)
//sys   Chdir(path string) (err error)
//sys   Chmod(path string, mode uint32) (err error)
//sys   Chown(path string, uid int, gid int) (err error)
//sys   Chroot(path string) (err error)
//sys   Close(fd int) (err error)
//sys   Creat(path string, mode uint32) (fd int, err error)
//sys   Dup(fd int) (nfd int, err error)
//sys   Dup2(oldfd int, newfd int) (err error)
//sys   Exit(code int)
//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   Fchown(fd int, uid int, gid int) (err error)
//sys   Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
//sys   Fdatasync(fd int) (err error)
//sys   Fpathconf(fd int, name int) (val int, err error)
//sys   Fstat(fd int, stat *Stat_t) (err error)
//sys   Getdents(fd int, buf []byte, basep *uintptr) (n int, err error)
//sysnb Getgid() (gid int)
//sysnb Getpid() (pid int)
//sysnb Getpgid(pid int) (pgid int, err error)
//sysnb Getpgrp() (pgid int, err error)
//sys   Geteuid() (euid int)
//sys   Getegid() (egid int)
//sys   Getppid() (ppid int)
//sys   Getpriority(which int, who int) (n int, err error)
//sysnb Getrlimit(which int, lim *Rlimit) (err error)
//sysnb Getrusage(who int, rusage *Rusage) (err error)
//sysnb Gettimeofday(tv *Timeval) (err error)
//sysnb Getuid() (uid int)
//sys   Kill(pid int, signum syscall.Signal) (err error)
//sys   Lchown(path string, uid int, gid int) (err error)
//sys   Link(path string, link string) (err error)
//sys   Listen(s int, backlog int) (err error) = libsocket.listen
//sys   Lstat(path string, stat *Stat_t) (err error)
//sys   Madvise(b []byte, advice int) (err error)
//sys   Mkdir(path string, mode uint32) (err error)
//sys   Mkdirat(dirfd int, path string, mode uint32) (err error)
//sys   Mkfifo(path string, mode uint32) (err error)
//sys   Mkfifoat(dirfd int, path string, mode uint32) (err error)
//sys   Mknod(path string, mode uint32, dev int) (err error)
//sys   Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
//sys   Mlock(b []byte) (err error)
//sys   Mlockall(flags int) (err error)
//sys   Mprotect(b []byte, prot int) (err error)
//sys   Munlock(b []byte) (err error)
//sys   Munlockall() (err error)
//sys   Nanosleep(time *Timespec, leftover *Timespec) (err error)
//sys   Open(path string, mode int, perm uint32) (fd int, err error)
//sys   Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
//sys   Pathconf(path string, name int) (val int, err error)
//sys   Pause() (err error)
//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   read(fd int, p []byte) (n int, err error)
//sys   Readlink(path string, buf []byte) (n int, err error)
//sys   Rename(from string, to string) (err error)
//sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
//sys   Rmdir(path string) (err error)
//sys   Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek
//sysnb Setegid(egid int) (err error)
//sysnb Seteuid(euid int) (err error)
//sysnb Setgid(gid int) (err error)
//sys   Sethostname(p []byte) (err error)
//sysnb Setpgid(pid int, pgid int) (err error)
//sys   Setpriority(which int, who int, prio int) (err error)
//sysnb Setregid(rgid int, egid int) (err error)
//sysnb Setreuid(ruid int, euid int) (err error)
//sysnb Setrlimit(which int, lim *Rlimit) (err error)
//sysnb Setsid() (pid int, err error)
//sysnb Setuid(uid int) (err error)
//sys   Shutdown(s int, how int) (err error) = libsocket.shutdown
//sys   Stat(path string, stat *Stat_t) (err error)
//sys   Symlink(path string, link string) (err error)
//sys   Sync() (err error)
//sysnb Times(tms *Tms) (ticks uintptr, err error)
//sys   Truncate(path string, length int64) (err error)
//sys   Fsync(fd int) (err error)
//sys   Ftruncate(fd int, length int64) (err error)
//sys   Umask(mask int) (oldmask int)
//sysnb Uname(buf *Utsname) (err error)
//sys   Unmount(target string, flags int) (err error) = libc.umount
//sys   Unlink(path string) (err error)
//sys   Unlinkat(dirfd int, path string, flags int) (err error)
//sys   Ustat(dev int, ubuf *Ustat_t) (err error)
//sys   Utime(path string, buf *Utimbuf) (err error)
//sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.bind
//sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.connect
//sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
//sys   munmap(addr uintptr, length uintptr) (err error)
//sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.sendto
//sys   socket(domain int, typ int, proto int) (fd int, err error) = libsocket.socket
//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.socketpair
//sys   write(fd int, p []byte) (n int, err error)
//sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.getsockopt
//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername
//sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt
//sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom

func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
    r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procread)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
    n = int(r0)
    if e1 != 0 {
        err = e1
    }
    return
}

func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
    r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procwrite)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
    n = int(r0)
    if e1 != 0 {
        err = e1
    }
    return
}

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)
}

//sys   sysconf(name int) (n int64, err error)

// pageSize caches the value of Getpagesize, since it can't change
// once the system is booted.
var pageSize int64 // accessed atomically

func Getpagesize() int {
    n := atomic.LoadInt64(&pageSize)
    if n == 0 {
        n, _ = sysconf(_SC_PAGESIZE)
        atomic.StoreInt64(&pageSize, n)
    }
    return int(n)
}