vendor/golang.org/x/sys/unix/syscall_solaris.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Solaris system calls.
   6 // This file is compiled as ordinary Go code,
   7 // but it is also input to mksyscall,
   8 // which parses the //sys lines and generates system call stubs.
   9 // Note that sometimes we use a lowercase //sys name and wrap
  10 // it in our own nicer implementation, either here or in
  11 // syscall_solaris.go or syscall_unix.go.
  12
  13 package unix
  14
  15 import (
  16         "syscall"
  17         "unsafe"
  18 )
  19
  20 // Implemented in runtime/syscall_solaris.go.
  21 type syscallFunc uintptr
  22
  23 func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
  24 func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
  25
  26 // SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
  27 type SockaddrDatalink struct {
  28         Family uint16
  29         Index  uint16
  30         Type   uint8
  31         Nlen   uint8
  32         Alen   uint8
  33         Slen   uint8
  34         Data   [244]int8
  35         raw    RawSockaddrDatalink
  36 }
  37
  38 //sysnb pipe(p *[2]_C_int) (n int, err error)
  39
  40 func Pipe(p []int) (err error) {
  41         if len(p) != 2 {
  42                 return EINVAL
  43         }
  44         var pp [2]_C_int
  45         n, err := pipe(&pp)
  46         if n != 0 {
  47                 return err
  48         }
  49         p[0] = int(pp[0])
  50         p[1] = int(pp[1])
  51         return nil
  52 }
  53
  54 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
  55         if sa.Port < 0 || sa.Port > 0xFFFF {
  56                 return nil, 0, EINVAL
  57         }
  58         sa.raw.Family = AF_INET
  59         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
  60         p[0] = byte(sa.Port >> 8)
  61         p[1] = byte(sa.Port)
  62         for i := 0; i < len(sa.Addr); i++ {
  63                 sa.raw.Addr[i] = sa.Addr[i]
  64         }
  65         return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
  66 }
  67
  68 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
  69         if sa.Port < 0 || sa.Port > 0xFFFF {
  70                 return nil, 0, EINVAL
  71         }
  72         sa.raw.Family = AF_INET6
  73         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
  74         p[0] = byte(sa.Port >> 8)
  75         p[1] = byte(sa.Port)
  76         sa.raw.Scope_id = sa.ZoneId
  77         for i := 0; i < len(sa.Addr); i++ {
  78                 sa.raw.Addr[i] = sa.Addr[i]
  79         }
  80         return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
  81 }
  82
  83 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
  84         name := sa.Name
  85         n := len(name)
  86         if n >= len(sa.raw.Path) {
  87                 return nil, 0, EINVAL
  88         }
  89         sa.raw.Family = AF_UNIX
  90         for i := 0; i < n; i++ {
  91                 sa.raw.Path[i] = int8(name[i])
  92         }
  93         // length is family (uint16), name, NUL.
  94         sl := _Socklen(2)
  95         if n > 0 {
  96                 sl += _Socklen(n) + 1
  97         }
  98         if sa.raw.Path[0] == '@' {
  99                 sa.raw.Path[0] = 0
 100                 // Don't count trailing NUL for abstract address.
 101                 sl--
 102         }
 103
 104         return unsafe.Pointer(&sa.raw), sl, nil
 105 }
 106
 107 //sys   getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname
 108
 109 func Getsockname(fd int) (sa Sockaddr, err error) {
 110         var rsa RawSockaddrAny
 111         var len _Socklen = SizeofSockaddrAny
 112         if err = getsockname(fd, &rsa, &len); err != nil {
 113                 return
 114         }
 115         return anyToSockaddr(fd, &rsa)
 116 }
 117
 118 // GetsockoptString returns the string value of the socket option opt for the
 119 // socket associated with fd at the given socket level.
 120 func GetsockoptString(fd, level, opt int) (string, error) {
 121         buf := make([]byte, 256)
 122         vallen := _Socklen(len(buf))
 123         err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
 124         if err != nil {
 125                 return "", err
 126         }
 127         return string(buf[:vallen-1]), nil
 128 }
 129
 130 const ImplementsGetwd = true
 131
 132 //sys   Getcwd(buf []byte) (n int, err error)
 133
 134 func Getwd() (wd string, err error) {
 135         var buf [PathMax]byte
 136         // Getcwd will return an error if it failed for any reason.
 137         _, err = Getcwd(buf[0:])
 138         if err != nil {
 139                 return "", err
 140         }
 141         n := clen(buf[:])
 142         if n < 1 {
 143                 return "", EINVAL
 144         }
 145         return string(buf[:n]), nil
 146 }
 147
 148 /*
 149  * Wrapped
 150  */
 151
 152 //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error)
 153 //sysnb setgroups(ngid int, gid *_Gid_t) (err error)
 154
 155 func Getgroups() (gids []int, err error) {
 156         n, err := getgroups(0, nil)
 157         // Check for error and sanity check group count. Newer versions of
 158         // Solaris allow up to 1024 (NGROUPS_MAX).
 159         if n < 0 || n > 1024 {
 160                 if err != nil {
 161                         return nil, err
 162                 }
 163                 return nil, EINVAL
 164         } else if n == 0 {
 165                 return nil, nil
 166         }
 167
 168         a := make([]_Gid_t, n)
 169         n, err = getgroups(n, &a[0])
 170         if n == -1 {
 171                 return nil, err
 172         }
 173         gids = make([]int, n)
 174         for i, v := range a[0:n] {
 175                 gids[i] = int(v)
 176         }
 177         return
 178 }
 179
 180 func Setgroups(gids []int) (err error) {
 181         if len(gids) == 0 {
 182                 return setgroups(0, nil)
 183         }
 184
 185         a := make([]_Gid_t, len(gids))
 186         for i, v := range gids {
 187                 a[i] = _Gid_t(v)
 188         }
 189         return setgroups(len(a), &a[0])
 190 }
 191
 192 func ReadDirent(fd int, buf []byte) (n int, err error) {
 193         // Final argument is (basep *uintptr) and the syscall doesn't take nil.
 194         // TODO(rsc): Can we use a single global basep for all calls?
 195         return Getdents(fd, buf, new(uintptr))
 196 }
 197
 198 // Wait status is 7 bits at bottom, either 0 (exited),
 199 // 0x7F (stopped), or a signal number that caused an exit.
 200 // The 0x80 bit is whether there was a core dump.
 201 // An extra number (exit code, signal causing a stop)
 202 // is in the high bits.
 203
 204 type WaitStatus uint32
 205
 206 const (
 207         mask  = 0x7F
 208         core  = 0x80
 209         shift = 8
 210
 211         exited  = 0
 212         stopped = 0x7F
 213 )
 214
 215 func (w WaitStatus) Exited() bool { return w&mask == exited }
 216
 217 func (w WaitStatus) ExitStatus() int {
 218         if w&mask != exited {
 219                 return -1
 220         }
 221         return int(w >> shift)
 222 }
 223
 224 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
 225
 226 func (w WaitStatus) Signal() syscall.Signal {
 227         sig := syscall.Signal(w & mask)
 228         if sig == stopped || sig == 0 {
 229                 return -1
 230         }
 231         return sig
 232 }
 233
 234 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
 235
 236 func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP }
 237
 238 func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }
 239
 240 func (w WaitStatus) StopSignal() syscall.Signal {
 241         if !w.Stopped() {
 242                 return -1
 243         }
 244         return syscall.Signal(w>>shift) & 0xFF
 245 }
 246
 247 func (w WaitStatus) TrapCause() int { return -1 }
 248
 249 //sys   wait4(pid int32, statusp *_C_int, options int, rusage *Rusage) (wpid int32, err error)
 250
 251 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (int, error) {
 252         var status _C_int
 253         rpid, err := wait4(int32(pid), &status, options, rusage)
 254         wpid := int(rpid)
 255         if wpid == -1 {
 256                 return wpid, err
 257         }
 258         if wstatus != nil {
 259                 *wstatus = WaitStatus(status)
 260         }
 261         return wpid, nil
 262 }
 263
 264 //sys   gethostname(buf []byte) (n int, err error)
 265
 266 func Gethostname() (name string, err error) {
 267         var buf [MaxHostNameLen]byte
 268         n, err := gethostname(buf[:])
 269         if n != 0 {
 270                 return "", err
 271         }
 272         n = clen(buf[:])
 273         if n < 1 {
 274                 return "", EFAULT
 275         }
 276         return string(buf[:n]), nil
 277 }
 278
 279 //sys   utimes(path string, times *[2]Timeval) (err error)
 280
 281 func Utimes(path string, tv []Timeval) (err error) {
 282         if tv == nil {
 283                 return utimes(path, nil)
 284         }
 285         if len(tv) != 2 {
 286                 return EINVAL
 287         }
 288         return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 289 }
 290
 291 //sys   utimensat(fd int, path string, times *[2]Timespec, flag int) (err error)
 292
 293 func UtimesNano(path string, ts []Timespec) error {
 294         if ts == nil {
 295                 return utimensat(AT_FDCWD, path, nil, 0)
 296         }
 297         if len(ts) != 2 {
 298                 return EINVAL
 299         }
 300         return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
 301 }
 302
 303 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
 304         if ts == nil {
 305                 return utimensat(dirfd, path, nil, flags)
 306         }
 307         if len(ts) != 2 {
 308                 return EINVAL
 309         }
 310         return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
 311 }
 312
 313 //sys   fcntl(fd int, cmd int, arg int) (val int, err error)
 314
 315 // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
 316 func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
 317         valptr, _, errno := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
 318         var err error
 319         if errno != 0 {
 320                 err = errno
 321         }
 322         return int(valptr), err
 323 }
 324
 325 // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
 326 func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
 327         _, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0)
 328         if e1 != 0 {
 329                 return e1
 330         }
 331         return nil
 332 }
 333
 334 //sys   futimesat(fildes int, path *byte, times *[2]Timeval) (err error)
 335
 336 func Futimesat(dirfd int, path string, tv []Timeval) error {
 337         pathp, err := BytePtrFromString(path)
 338         if err != nil {
 339                 return err
 340         }
 341         if tv == nil {
 342                 return futimesat(dirfd, pathp, nil)
 343         }
 344         if len(tv) != 2 {
 345                 return EINVAL
 346         }
 347         return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 348 }
 349
 350 // Solaris doesn't have an futimes function because it allows NULL to be
 351 // specified as the path for futimesat. However, Go doesn't like
 352 // NULL-style string interfaces, so this simple wrapper is provided.
 353 func Futimes(fd int, tv []Timeval) error {
 354         if tv == nil {
 355                 return futimesat(fd, nil, nil)
 356         }
 357         if len(tv) != 2 {
 358                 return EINVAL
 359         }
 360         return futimesat(fd, nil, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 361 }
 362
 363 func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
 364         switch rsa.Addr.Family {
 365         case AF_UNIX:
 366                 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
 367                 sa := new(SockaddrUnix)
 368                 // Assume path ends at NUL.
 369                 // This is not technically the Solaris semantics for
 370                 // abstract Unix domain sockets -- they are supposed
 371                 // to be uninterpreted fixed-size binary blobs -- but
 372                 // everyone uses this convention.
 373                 n := 0
 374                 for n < len(pp.Path) && pp.Path[n] != 0 {
 375                         n++
 376                 }
 377                 bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
 378                 sa.Name = string(bytes)
 379                 return sa, nil
 380
 381         case AF_INET:
 382                 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
 383                 sa := new(SockaddrInet4)
 384                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 385                 sa.Port = int(p[0])<<8 + int(p[1])
 386                 for i := 0; i < len(sa.Addr); i++ {
 387                         sa.Addr[i] = pp.Addr[i]
 388                 }
 389                 return sa, nil
 390
 391         case AF_INET6:
 392                 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
 393                 sa := new(SockaddrInet6)
 394                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 395                 sa.Port = int(p[0])<<8 + int(p[1])
 396                 sa.ZoneId = pp.Scope_id
 397                 for i := 0; i < len(sa.Addr); i++ {
 398                         sa.Addr[i] = pp.Addr[i]
 399                 }
 400                 return sa, nil
 401         }
 402         return nil, EAFNOSUPPORT
 403 }
 404
 405 //sys   accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept
 406
 407 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
 408         var rsa RawSockaddrAny
 409         var len _Socklen = SizeofSockaddrAny
 410         nfd, err = accept(fd, &rsa, &len)
 411         if nfd == -1 {
 412                 return
 413         }
 414         sa, err = anyToSockaddr(fd, &rsa)
 415         if err != nil {
 416                 Close(nfd)
 417                 nfd = 0
 418         }
 419         return
 420 }
 421
 422 //sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_recvmsg
 423
 424 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
 425         var msg Msghdr
 426         var rsa RawSockaddrAny
 427         msg.Name = (*byte)(unsafe.Pointer(&rsa))
 428         msg.Namelen = uint32(SizeofSockaddrAny)
 429         var iov Iovec
 430         if len(p) > 0 {
 431                 iov.Base = (*int8)(unsafe.Pointer(&p[0]))
 432                 iov.SetLen(len(p))
 433         }
 434         var dummy int8
 435         if len(oob) > 0 {
 436                 // receive at least one normal byte
 437                 if len(p) == 0 {
 438                         iov.Base = &dummy
 439                         iov.SetLen(1)
 440                 }
 441                 msg.Accrightslen = int32(len(oob))
 442         }
 443         msg.Iov = &iov
 444         msg.Iovlen = 1
 445         if n, err = recvmsg(fd, &msg, flags); n == -1 {
 446                 return
 447         }
 448         oobn = int(msg.Accrightslen)
 449         // source address is only specified if the socket is unconnected
 450         if rsa.Addr.Family != AF_UNSPEC {
 451                 from, err = anyToSockaddr(fd, &rsa)
 452         }
 453         return
 454 }
 455
 456 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
 457         _, err = SendmsgN(fd, p, oob, to, flags)
 458         return
 459 }
 460
 461 //sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_sendmsg
 462
 463 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
 464         var ptr unsafe.Pointer
 465         var salen _Socklen
 466         if to != nil {
 467                 ptr, salen, err = to.sockaddr()
 468                 if err != nil {
 469                         return 0, err
 470                 }
 471         }
 472         var msg Msghdr
 473         msg.Name = (*byte)(unsafe.Pointer(ptr))
 474         msg.Namelen = uint32(salen)
 475         var iov Iovec
 476         if len(p) > 0 {
 477                 iov.Base = (*int8)(unsafe.Pointer(&p[0]))
 478                 iov.SetLen(len(p))
 479         }
 480         var dummy int8
 481         if len(oob) > 0 {
 482                 // send at least one normal byte
 483                 if len(p) == 0 {
 484                         iov.Base = &dummy
 485                         iov.SetLen(1)
 486                 }
 487                 msg.Accrightslen = int32(len(oob))
 488         }
 489         msg.Iov = &iov
 490         msg.Iovlen = 1
 491         if n, err = sendmsg(fd, &msg, flags); err != nil {
 492                 return 0, err
 493         }
 494         if len(oob) > 0 && len(p) == 0 {
 495                 n = 0
 496         }
 497         return n, nil
 498 }
 499
 500 //sys   acct(path *byte) (err error)
 501
 502 func Acct(path string) (err error) {
 503         if len(path) == 0 {
 504                 // Assume caller wants to disable accounting.
 505                 return acct(nil)
 506         }
 507
 508         pathp, err := BytePtrFromString(path)
 509         if err != nil {
 510                 return err
 511         }
 512         return acct(pathp)
 513 }
 514
 515 //sys   __makedev(version int, major uint, minor uint) (val uint64)
 516
 517 func Mkdev(major, minor uint32) uint64 {
 518         return __makedev(NEWDEV, uint(major), uint(minor))
 519 }
 520
 521 //sys   __major(version int, dev uint64) (val uint)
 522
 523 func Major(dev uint64) uint32 {
 524         return uint32(__major(NEWDEV, dev))
 525 }
 526
 527 //sys   __minor(version int, dev uint64) (val uint)
 528
 529 func Minor(dev uint64) uint32 {
 530         return uint32(__minor(NEWDEV, dev))
 531 }
 532
 533 /*
 534  * Expose the ioctl function
 535  */
 536
 537 //sys   ioctl(fd int, req uint, arg uintptr) (err error)
 538
 539 func IoctlSetInt(fd int, req uint, value int) (err error) {
 540         return ioctl(fd, req, uintptr(value))
 541 }
 542
 543 func ioctlSetWinsize(fd int, req uint, value *Winsize) (err error) {
 544         return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
 545 }
 546
 547 func ioctlSetTermios(fd int, req uint, value *Termios) (err error) {
 548         return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
 549 }
 550
 551 func IoctlSetTermio(fd int, req uint, value *Termio) (err error) {
 552         return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
 553 }
 554
 555 func IoctlGetInt(fd int, req uint) (int, error) {
 556         var value int
 557         err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
 558         return value, err
 559 }
 560
 561 func IoctlGetWinsize(fd int, req uint) (*Winsize, error) {
 562         var value Winsize
 563         err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
 564         return &value, err
 565 }
 566
 567 func IoctlGetTermios(fd int, req uint) (*Termios, error) {
 568         var value Termios
 569         err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
 570         return &value, err
 571 }
 572
 573 func IoctlGetTermio(fd int, req uint) (*Termio, error) {
 574         var value Termio
 575         err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
 576         return &value, err
 577 }
 578
 579 //sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 580
 581 func Poll(fds []PollFd, timeout int) (n int, err error) {
 582         if len(fds) == 0 {
 583                 return poll(nil, 0, timeout)
 584         }
 585         return poll(&fds[0], len(fds), timeout)
 586 }
 587
 588 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 589         if raceenabled {
 590                 raceReleaseMerge(unsafe.Pointer(&ioSync))
 591         }
 592         return sendfile(outfd, infd, offset, count)
 593 }
 594
 595 /*
 596  * Exposed directly
 597  */
 598 //sys   Access(path string, mode uint32) (err error)
 599 //sys   Adjtime(delta *Timeval, olddelta *Timeval) (err error)
 600 //sys   Chdir(path string) (err error)
 601 //sys   Chmod(path string, mode uint32) (err error)
 602 //sys   Chown(path string, uid int, gid int) (err error)
 603 //sys   Chroot(path string) (err error)
 604 //sys   Close(fd int) (err error)
 605 //sys   Creat(path string, mode uint32) (fd int, err error)
 606 //sys   Dup(fd int) (nfd int, err error)
 607 //sys   Dup2(oldfd int, newfd int) (err error)
 608 //sys   Exit(code int)
 609 //sys   Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 610 //sys   Fchdir(fd int) (err error)
 611 //sys   Fchmod(fd int, mode uint32) (err error)
 612 //sys   Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
 613 //sys   Fchown(fd int, uid int, gid int) (err error)
 614 //sys   Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
 615 //sys   Fdatasync(fd int) (err error)
 616 //sys   Flock(fd int, how int) (err error)
 617 //sys   Fpathconf(fd int, name int) (val int, err error)
 618 //sys   Fstat(fd int, stat *Stat_t) (err error)
 619 //sys   Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
 620 //sys   Fstatvfs(fd int, vfsstat *Statvfs_t) (err error)
 621 //sys   Getdents(fd int, buf []byte, basep *uintptr) (n int, err error)
 622 //sysnb Getgid() (gid int)
 623 //sysnb Getpid() (pid int)
 624 //sysnb Getpgid(pid int) (pgid int, err error)
 625 //sysnb Getpgrp() (pgid int, err error)
 626 //sys   Geteuid() (euid int)
 627 //sys   Getegid() (egid int)
 628 //sys   Getppid() (ppid int)
 629 //sys   Getpriority(which int, who int) (n int, err error)
 630 //sysnb Getrlimit(which int, lim *Rlimit) (err error)
 631 //sysnb Getrusage(who int, rusage *Rusage) (err error)
 632 //sysnb Gettimeofday(tv *Timeval) (err error)
 633 //sysnb Getuid() (uid int)
 634 //sys   Kill(pid int, signum syscall.Signal) (err error)
 635 //sys   Lchown(path string, uid int, gid int) (err error)
 636 //sys   Link(path string, link string) (err error)
 637 //sys   Listen(s int, backlog int) (err error) = libsocket.__xnet_llisten
 638 //sys   Lstat(path string, stat *Stat_t) (err error)
 639 //sys   Madvise(b []byte, advice int) (err error)
 640 //sys   Mkdir(path string, mode uint32) (err error)
 641 //sys   Mkdirat(dirfd int, path string, mode uint32) (err error)
 642 //sys   Mkfifo(path string, mode uint32) (err error)
 643 //sys   Mkfifoat(dirfd int, path string, mode uint32) (err error)
 644 //sys   Mknod(path string, mode uint32, dev int) (err error)
 645 //sys   Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
 646 //sys   Mlock(b []byte) (err error)
 647 //sys   Mlockall(flags int) (err error)
 648 //sys   Mprotect(b []byte, prot int) (err error)
 649 //sys   Msync(b []byte, flags int) (err error)
 650 //sys   Munlock(b []byte) (err error)
 651 //sys   Munlockall() (err error)
 652 //sys   Nanosleep(time *Timespec, leftover *Timespec) (err error)
 653 //sys   Open(path string, mode int, perm uint32) (fd int, err error)
 654 //sys   Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
 655 //sys   Pathconf(path string, name int) (val int, err error)
 656 //sys   Pause() (err error)
 657 //sys   Pread(fd int, p []byte, offset int64) (n int, err error)
 658 //sys   Pwrite(fd int, p []byte, offset int64) (n int, err error)
 659 //sys   read(fd int, p []byte) (n int, err error)
 660 //sys   Readlink(path string, buf []byte) (n int, err error)
 661 //sys   Rename(from string, to string) (err error)
 662 //sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
 663 //sys   Rmdir(path string) (err error)
 664 //sys   Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek
 665 //sys   Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error)
 666 //sysnb Setegid(egid int) (err error)
 667 //sysnb Seteuid(euid int) (err error)
 668 //sysnb Setgid(gid int) (err error)
 669 //sys   Sethostname(p []byte) (err error)
 670 //sysnb Setpgid(pid int, pgid int) (err error)
 671 //sys   Setpriority(which int, who int, prio int) (err error)
 672 //sysnb Setregid(rgid int, egid int) (err error)
 673 //sysnb Setreuid(ruid int, euid int) (err error)
 674 //sysnb Setrlimit(which int, lim *Rlimit) (err error)
 675 //sysnb Setsid() (pid int, err error)
 676 //sysnb Setuid(uid int) (err error)
 677 //sys   Shutdown(s int, how int) (err error) = libsocket.shutdown
 678 //sys   Stat(path string, stat *Stat_t) (err error)
 679 //sys   Statvfs(path string, vfsstat *Statvfs_t) (err error)
 680 //sys   Symlink(path string, link string) (err error)
 681 //sys   Sync() (err error)
 682 //sysnb Times(tms *Tms) (ticks uintptr, err error)
 683 //sys   Truncate(path string, length int64) (err error)
 684 //sys   Fsync(fd int) (err error)
 685 //sys   Ftruncate(fd int, length int64) (err error)
 686 //sys   Umask(mask int) (oldmask int)
 687 //sysnb Uname(buf *Utsname) (err error)
 688 //sys   Unmount(target string, flags int) (err error) = libc.umount
 689 //sys   Unlink(path string) (err error)
 690 //sys   Unlinkat(dirfd int, path string, flags int) (err error)
 691 //sys   Ustat(dev int, ubuf *Ustat_t) (err error)
 692 //sys   Utime(path string, buf *Utimbuf) (err error)
 693 //sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_bind
 694 //sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_connect
 695 //sys   mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
 696 //sys   munmap(addr uintptr, length uintptr) (err error)
 697 //sys   sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = libsendfile.sendfile
 698 //sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_sendto
 699 //sys   socket(domain int, typ int, proto int) (fd int, err error) = libsocket.__xnet_socket
 700 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.__xnet_socketpair
 701 //sys   write(fd int, p []byte) (n int, err error)
 702 //sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.__xnet_getsockopt
 703 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername
 704 //sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt
 705 //sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom
 706
 707 func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
 708         r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procread)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
 709         n = int(r0)
 710         if e1 != 0 {
 711                 err = e1
 712         }
 713         return
 714 }
 715
 716 func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
 717         r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procwrite)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
 718         n = int(r0)
 719         if e1 != 0 {
 720                 err = e1
 721         }
 722         return
 723 }
 724
 725 var mapper = &mmapper{
 726         active: make(map[*byte][]byte),
 727         mmap:   mmap,
 728         munmap: munmap,
 729 }
 730
 731 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
 732         return mapper.Mmap(fd, offset, length, prot, flags)
 733 }
 734
 735 func Munmap(b []byte) (err error) {
 736         return mapper.Munmap(b)
 737 }