vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_bsd.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 // +build darwin dragonfly freebsd netbsd openbsd
   6
   7 // BSD system call wrappers shared by *BSD based systems
   8 // including OS X (Darwin) and FreeBSD.  Like the other
   9 // syscall_*.go files it is compiled as Go code but also
  10 // used as input to mksyscall which parses the //sys
  11 // lines and generates system call stubs.
  12
  13 package unix
  14
  15 import (
  16         "runtime"
  17         "syscall"
  18         "unsafe"
  19 )
  20
  21 /*
  22  * Wrapped
  23  */
  24
  25 //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error)
  26 //sysnb setgroups(ngid int, gid *_Gid_t) (err error)
  27
  28 func Getgroups() (gids []int, err error) {
  29         n, err := getgroups(0, nil)
  30         if err != nil {
  31                 return nil, err
  32         }
  33         if n == 0 {
  34                 return nil, nil
  35         }
  36
  37         // Sanity check group count.  Max is 16 on BSD.
  38         if n < 0 || n > 1000 {
  39                 return nil, EINVAL
  40         }
  41
  42         a := make([]_Gid_t, n)
  43         n, err = getgroups(n, &a[0])
  44         if err != nil {
  45                 return nil, err
  46         }
  47         gids = make([]int, n)
  48         for i, v := range a[0:n] {
  49                 gids[i] = int(v)
  50         }
  51         return
  52 }
  53
  54 func Setgroups(gids []int) (err error) {
  55         if len(gids) == 0 {
  56                 return setgroups(0, nil)
  57         }
  58
  59         a := make([]_Gid_t, len(gids))
  60         for i, v := range gids {
  61                 a[i] = _Gid_t(v)
  62         }
  63         return setgroups(len(a), &a[0])
  64 }
  65
  66 func ReadDirent(fd int, buf []byte) (n int, err error) {
  67         // Final argument is (basep *uintptr) and the syscall doesn't take nil.
  68         // 64 bits should be enough. (32 bits isn't even on 386). Since the
  69         // actual system call is getdirentries64, 64 is a good guess.
  70         // TODO(rsc): Can we use a single global basep for all calls?
  71         var base = (*uintptr)(unsafe.Pointer(new(uint64)))
  72         return Getdirentries(fd, buf, base)
  73 }
  74
  75 // Wait status is 7 bits at bottom, either 0 (exited),
  76 // 0x7F (stopped), or a signal number that caused an exit.
  77 // The 0x80 bit is whether there was a core dump.
  78 // An extra number (exit code, signal causing a stop)
  79 // is in the high bits.
  80
  81 type WaitStatus uint32
  82
  83 const (
  84         mask  = 0x7F
  85         core  = 0x80
  86         shift = 8
  87
  88         exited  = 0
  89         stopped = 0x7F
  90 )
  91
  92 func (w WaitStatus) Exited() bool { return w&mask == exited }
  93
  94 func (w WaitStatus) ExitStatus() int {
  95         if w&mask != exited {
  96                 return -1
  97         }
  98         return int(w >> shift)
  99 }
 100
 101 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
 102
 103 func (w WaitStatus) Signal() syscall.Signal {
 104         sig := syscall.Signal(w & mask)
 105         if sig == stopped || sig == 0 {
 106                 return -1
 107         }
 108         return sig
 109 }
 110
 111 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
 112
 113 func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP }
 114
 115 func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }
 116
 117 func (w WaitStatus) StopSignal() syscall.Signal {
 118         if !w.Stopped() {
 119                 return -1
 120         }
 121         return syscall.Signal(w>>shift) & 0xFF
 122 }
 123
 124 func (w WaitStatus) TrapCause() int { return -1 }
 125
 126 //sys   wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)
 127
 128 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
 129         var status _C_int
 130         wpid, err = wait4(pid, &status, options, rusage)
 131         if wstatus != nil {
 132                 *wstatus = WaitStatus(status)
 133         }
 134         return
 135 }
 136
 137 //sys   accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
 138 //sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 139 //sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 140 //sysnb socket(domain int, typ int, proto int) (fd int, err error)
 141 //sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
 142 //sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
 143 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 144 //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 145 //sys   Shutdown(s int, how int) (err error)
 146
 147 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
 148         if sa.Port < 0 || sa.Port > 0xFFFF {
 149                 return nil, 0, EINVAL
 150         }
 151         sa.raw.Len = SizeofSockaddrInet4
 152         sa.raw.Family = AF_INET
 153         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 154         p[0] = byte(sa.Port >> 8)
 155         p[1] = byte(sa.Port)
 156         for i := 0; i < len(sa.Addr); i++ {
 157                 sa.raw.Addr[i] = sa.Addr[i]
 158         }
 159         return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 160 }
 161
 162 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
 163         if sa.Port < 0 || sa.Port > 0xFFFF {
 164                 return nil, 0, EINVAL
 165         }
 166         sa.raw.Len = SizeofSockaddrInet6
 167         sa.raw.Family = AF_INET6
 168         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 169         p[0] = byte(sa.Port >> 8)
 170         p[1] = byte(sa.Port)
 171         sa.raw.Scope_id = sa.ZoneId
 172         for i := 0; i < len(sa.Addr); i++ {
 173                 sa.raw.Addr[i] = sa.Addr[i]
 174         }
 175         return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 176 }
 177
 178 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
 179         name := sa.Name
 180         n := len(name)
 181         if n >= len(sa.raw.Path) || n == 0 {
 182                 return nil, 0, EINVAL
 183         }
 184         sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
 185         sa.raw.Family = AF_UNIX
 186         for i := 0; i < n; i++ {
 187                 sa.raw.Path[i] = int8(name[i])
 188         }
 189         return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
 190 }
 191
 192 func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) {
 193         if sa.Index == 0 {
 194                 return nil, 0, EINVAL
 195         }
 196         sa.raw.Len = sa.Len
 197         sa.raw.Family = AF_LINK
 198         sa.raw.Index = sa.Index
 199         sa.raw.Type = sa.Type
 200         sa.raw.Nlen = sa.Nlen
 201         sa.raw.Alen = sa.Alen
 202         sa.raw.Slen = sa.Slen
 203         for i := 0; i < len(sa.raw.Data); i++ {
 204                 sa.raw.Data[i] = sa.Data[i]
 205         }
 206         return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil
 207 }
 208
 209 func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
 210         switch rsa.Addr.Family {
 211         case AF_LINK:
 212                 pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa))
 213                 sa := new(SockaddrDatalink)
 214                 sa.Len = pp.Len
 215                 sa.Family = pp.Family
 216                 sa.Index = pp.Index
 217                 sa.Type = pp.Type
 218                 sa.Nlen = pp.Nlen
 219                 sa.Alen = pp.Alen
 220                 sa.Slen = pp.Slen
 221                 for i := 0; i < len(sa.Data); i++ {
 222                         sa.Data[i] = pp.Data[i]
 223                 }
 224                 return sa, nil
 225
 226         case AF_UNIX:
 227                 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
 228                 if pp.Len < 2 || pp.Len > SizeofSockaddrUnix {
 229                         return nil, EINVAL
 230                 }
 231                 sa := new(SockaddrUnix)
 232
 233                 // Some BSDs include the trailing NUL in the length, whereas
 234                 // others do not. Work around this by subtracting the leading
 235                 // family and len. The path is then scanned to see if a NUL
 236                 // terminator still exists within the length.
 237                 n := int(pp.Len) - 2 // subtract leading Family, Len
 238                 for i := 0; i < n; i++ {
 239                         if pp.Path[i] == 0 {
 240                                 // found early NUL; assume Len included the NUL
 241                                 // or was overestimating.
 242                                 n = i
 243                                 break
 244                         }
 245                 }
 246                 bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
 247                 sa.Name = string(bytes)
 248                 return sa, nil
 249
 250         case AF_INET:
 251                 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
 252                 sa := new(SockaddrInet4)
 253                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 254                 sa.Port = int(p[0])<<8 + int(p[1])
 255                 for i := 0; i < len(sa.Addr); i++ {
 256                         sa.Addr[i] = pp.Addr[i]
 257                 }
 258                 return sa, nil
 259
 260         case AF_INET6:
 261                 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
 262                 sa := new(SockaddrInet6)
 263                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 264                 sa.Port = int(p[0])<<8 + int(p[1])
 265                 sa.ZoneId = pp.Scope_id
 266                 for i := 0; i < len(sa.Addr); i++ {
 267                         sa.Addr[i] = pp.Addr[i]
 268                 }
 269                 return sa, nil
 270         }
 271         return nil, EAFNOSUPPORT
 272 }
 273
 274 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
 275         var rsa RawSockaddrAny
 276         var len _Socklen = SizeofSockaddrAny
 277         nfd, err = accept(fd, &rsa, &len)
 278         if err != nil {
 279                 return
 280         }
 281         if runtime.GOOS == "darwin" && len == 0 {
 282                 // Accepted socket has no address.
 283                 // This is likely due to a bug in xnu kernels,
 284                 // where instead of ECONNABORTED error socket
 285                 // is accepted, but has no address.
 286                 Close(nfd)
 287                 return 0, nil, ECONNABORTED
 288         }
 289         sa, err = anyToSockaddr(&rsa)
 290         if err != nil {
 291                 Close(nfd)
 292                 nfd = 0
 293         }
 294         return
 295 }
 296
 297 func Getsockname(fd int) (sa Sockaddr, err error) {
 298         var rsa RawSockaddrAny
 299         var len _Socklen = SizeofSockaddrAny
 300         if err = getsockname(fd, &rsa, &len); err != nil {
 301                 return
 302         }
 303         // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be
 304         // reported upstream.
 305         if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 {
 306                 rsa.Addr.Family = AF_UNIX
 307                 rsa.Addr.Len = SizeofSockaddrUnix
 308         }
 309         return anyToSockaddr(&rsa)
 310 }
 311
 312 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
 313
 314 func GetsockoptByte(fd, level, opt int) (value byte, err error) {
 315         var n byte
 316         vallen := _Socklen(1)
 317         err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
 318         return n, err
 319 }
 320
 321 func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) {
 322         vallen := _Socklen(4)
 323         err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
 324         return value, err
 325 }
 326
 327 func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) {
 328         var value IPMreq
 329         vallen := _Socklen(SizeofIPMreq)
 330         err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 331         return &value, err
 332 }
 333
 334 func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) {
 335         var value IPv6Mreq
 336         vallen := _Socklen(SizeofIPv6Mreq)
 337         err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 338         return &value, err
 339 }
 340
 341 func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
 342         var value IPv6MTUInfo
 343         vallen := _Socklen(SizeofIPv6MTUInfo)
 344         err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 345         return &value, err
 346 }
 347
 348 func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) {
 349         var value ICMPv6Filter
 350         vallen := _Socklen(SizeofICMPv6Filter)
 351         err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
 352         return &value, err
 353 }
 354
 355 //sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
 356 //sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
 357 //sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
 358
 359 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
 360         var msg Msghdr
 361         var rsa RawSockaddrAny
 362         msg.Name = (*byte)(unsafe.Pointer(&rsa))
 363         msg.Namelen = uint32(SizeofSockaddrAny)
 364         var iov Iovec
 365         if len(p) > 0 {
 366                 iov.Base = (*byte)(unsafe.Pointer(&p[0]))
 367                 iov.SetLen(len(p))
 368         }
 369         var dummy byte
 370         if len(oob) > 0 {
 371                 // receive at least one normal byte
 372                 if len(p) == 0 {
 373                         iov.Base = &dummy
 374                         iov.SetLen(1)
 375                 }
 376                 msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
 377                 msg.SetControllen(len(oob))
 378         }
 379         msg.Iov = &iov
 380         msg.Iovlen = 1
 381         if n, err = recvmsg(fd, &msg, flags); err != nil {
 382                 return
 383         }
 384         oobn = int(msg.Controllen)
 385         recvflags = int(msg.Flags)
 386         // source address is only specified if the socket is unconnected
 387         if rsa.Addr.Family != AF_UNSPEC {
 388                 from, err = anyToSockaddr(&rsa)
 389         }
 390         return
 391 }
 392
 393 //sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error)
 394
 395 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
 396         _, err = SendmsgN(fd, p, oob, to, flags)
 397         return
 398 }
 399
 400 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
 401         var ptr unsafe.Pointer
 402         var salen _Socklen
 403         if to != nil {
 404                 ptr, salen, err = to.sockaddr()
 405                 if err != nil {
 406                         return 0, err
 407                 }
 408         }
 409         var msg Msghdr
 410         msg.Name = (*byte)(unsafe.Pointer(ptr))
 411         msg.Namelen = uint32(salen)
 412         var iov Iovec
 413         if len(p) > 0 {
 414                 iov.Base = (*byte)(unsafe.Pointer(&p[0]))
 415                 iov.SetLen(len(p))
 416         }
 417         var dummy byte
 418         if len(oob) > 0 {
 419                 // send at least one normal byte
 420                 if len(p) == 0 {
 421                         iov.Base = &dummy
 422                         iov.SetLen(1)
 423                 }
 424                 msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
 425                 msg.SetControllen(len(oob))
 426         }
 427         msg.Iov = &iov
 428         msg.Iovlen = 1
 429         if n, err = sendmsg(fd, &msg, flags); err != nil {
 430                 return 0, err
 431         }
 432         if len(oob) > 0 && len(p) == 0 {
 433                 n = 0
 434         }
 435         return n, nil
 436 }
 437
 438 //sys   kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error)
 439
 440 func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) {
 441         var change, event unsafe.Pointer
 442         if len(changes) > 0 {
 443                 change = unsafe.Pointer(&changes[0])
 444         }
 445         if len(events) > 0 {
 446                 event = unsafe.Pointer(&events[0])
 447         }
 448         return kevent(kq, change, len(changes), event, len(events), timeout)
 449 }
 450
 451 //sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL
 452
 453 // sysctlmib translates name to mib number and appends any additional args.
 454 func sysctlmib(name string, args ...int) ([]_C_int, error) {
 455         // Translate name to mib number.
 456         mib, err := nametomib(name)
 457         if err != nil {
 458                 return nil, err
 459         }
 460
 461         for _, a := range args {
 462                 mib = append(mib, _C_int(a))
 463         }
 464
 465         return mib, nil
 466 }
 467
 468 func Sysctl(name string) (string, error) {
 469         return SysctlArgs(name)
 470 }
 471
 472 func SysctlArgs(name string, args ...int) (string, error) {
 473         mib, err := sysctlmib(name, args...)
 474         if err != nil {
 475                 return "", err
 476         }
 477
 478         // Find size.
 479         n := uintptr(0)
 480         if err := sysctl(mib, nil, &n, nil, 0); err != nil {
 481                 return "", err
 482         }
 483         if n == 0 {
 484                 return "", nil
 485         }
 486
 487         // Read into buffer of that size.
 488         buf := make([]byte, n)
 489         if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 490                 return "", err
 491         }
 492
 493         // Throw away terminating NUL.
 494         if n > 0 && buf[n-1] == '\x00' {
 495                 n--
 496         }
 497         return string(buf[0:n]), nil
 498 }
 499
 500 func SysctlUint32(name string) (uint32, error) {
 501         return SysctlUint32Args(name)
 502 }
 503
 504 func SysctlUint32Args(name string, args ...int) (uint32, error) {
 505         mib, err := sysctlmib(name, args...)
 506         if err != nil {
 507                 return 0, err
 508         }
 509
 510         n := uintptr(4)
 511         buf := make([]byte, 4)
 512         if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 513                 return 0, err
 514         }
 515         if n != 4 {
 516                 return 0, EIO
 517         }
 518         return *(*uint32)(unsafe.Pointer(&buf[0])), nil
 519 }
 520
 521 func SysctlUint64(name string, args ...int) (uint64, error) {
 522         mib, err := sysctlmib(name, args...)
 523         if err != nil {
 524                 return 0, err
 525         }
 526
 527         n := uintptr(8)
 528         buf := make([]byte, 8)
 529         if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 530                 return 0, err
 531         }
 532         if n != 8 {
 533                 return 0, EIO
 534         }
 535         return *(*uint64)(unsafe.Pointer(&buf[0])), nil
 536 }
 537
 538 func SysctlRaw(name string, args ...int) ([]byte, error) {
 539         mib, err := sysctlmib(name, args...)
 540         if err != nil {
 541                 return nil, err
 542         }
 543
 544         // Find size.
 545         n := uintptr(0)
 546         if err := sysctl(mib, nil, &n, nil, 0); err != nil {
 547                 return nil, err
 548         }
 549         if n == 0 {
 550                 return nil, nil
 551         }
 552
 553         // Read into buffer of that size.
 554         buf := make([]byte, n)
 555         if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil {
 556                 return nil, err
 557         }
 558
 559         // The actual call may return less than the original reported required
 560         // size so ensure we deal with that.
 561         return buf[:n], nil
 562 }
 563
 564 //sys   utimes(path string, timeval *[2]Timeval) (err error)
 565
 566 func Utimes(path string, tv []Timeval) error {
 567         if tv == nil {
 568                 return utimes(path, nil)
 569         }
 570         if len(tv) != 2 {
 571                 return EINVAL
 572         }
 573         return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 574 }
 575
 576 func UtimesNano(path string, ts []Timespec) error {
 577         if ts == nil {
 578                 return utimes(path, nil)
 579         }
 580         // TODO: The BSDs can do utimensat with SYS_UTIMENSAT but it
 581         // isn't supported by darwin so this uses utimes instead
 582         if len(ts) != 2 {
 583                 return EINVAL
 584         }
 585         // Not as efficient as it could be because Timespec and
 586         // Timeval have different types in the different OSes
 587         tv := [2]Timeval{
 588                 NsecToTimeval(TimespecToNsec(ts[0])),
 589                 NsecToTimeval(TimespecToNsec(ts[1])),
 590         }
 591         return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 592 }
 593
 594 //sys   futimes(fd int, timeval *[2]Timeval) (err error)
 595
 596 func Futimes(fd int, tv []Timeval) error {
 597         if tv == nil {
 598                 return futimes(fd, nil)
 599         }
 600         if len(tv) != 2 {
 601                 return EINVAL
 602         }
 603         return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
 604 }
 605
 606 //sys   fcntl(fd int, cmd int, arg int) (val int, err error)
 607
 608 // TODO: wrap
 609 //      Acct(name nil-string) (err error)
 610 //      Gethostuuid(uuid *byte, timeout *Timespec) (err error)
 611 //      Madvise(addr *byte, len int, behav int) (err error)
 612 //      Mprotect(addr *byte, len int, prot int) (err error)
 613 //      Msync(addr *byte, len int, flags int) (err error)
 614 //      Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error)
 615
 616 var mapper = &mmapper{
 617         active: make(map[*byte][]byte),
 618         mmap:   mmap,
 619         munmap: munmap,
 620 }
 621
 622 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
 623         return mapper.Mmap(fd, offset, length, prot, flags)
 624 }
 625
 626 func Munmap(b []byte) (err error) {
 627         return mapper.Munmap(b)
 628 }