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