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