github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/syscall/syscall_aix.go (about) 1 // Copyright 2018 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 // Aix 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 10 // wrap it in our own nicer implementation. 11 12 package syscall 13 14 import ( 15 "unsafe" 16 ) 17 18 // Implemented in runtime/syscall_aix.go. 19 func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 20 func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) 21 22 // Constant expected by package but not supported 23 const ( 24 _ = iota 25 TIOCSCTTY 26 SYS_EXECVE 27 SYS_FCNTL 28 ) 29 30 const ( 31 F_DUPFD_CLOEXEC = 0 32 // AF_LOCAL doesn't exist on AIX 33 AF_LOCAL = AF_UNIX 34 ) 35 36 func (ts *StTimespec_t) Unix() (sec int64, nsec int64) { 37 return int64(ts.Sec), int64(ts.Nsec) 38 } 39 40 func (ts *StTimespec_t) Nano() int64 { 41 return int64(ts.Sec)*1e9 + int64(ts.Nsec) 42 } 43 44 /* 45 * Wrapped 46 */ 47 48 func Access(path string, mode uint32) (err error) { 49 return Faccessat(_AT_FDCWD, path, mode, 0) 50 } 51 52 // fcntl must never be called with cmd=F_DUP2FD because it doesn't work on AIX 53 // There is no way to create a custom fcntl and to keep //sys fcntl easily, 54 // because we need fcntl name for its libc symbol. This is linked with the script. 55 // But, as fcntl is currently not exported and isn't called with F_DUP2FD, 56 // it doesn't matter. 57 //sys fcntl(fd int, cmd int, arg int) (val int, err error) 58 //sys Dup2(old int, new int) (err error) 59 60 //sysnb pipe(p *[2]_C_int) (err error) 61 func Pipe(p []int) (err error) { 62 if len(p) != 2 { 63 return EINVAL 64 } 65 var pp [2]_C_int 66 err = pipe(&pp) 67 if err == nil { 68 p[0] = int(pp[0]) 69 p[1] = int(pp[1]) 70 } 71 return 72 } 73 74 //sys readlink(path string, buf []byte, bufSize uint64) (n int, err error) 75 func Readlink(path string, buf []byte) (n int, err error) { 76 s := uint64(len(buf)) 77 return readlink(path, buf, s) 78 } 79 80 //sys utimes(path string, times *[2]Timeval) (err error) 81 func Utimes(path string, tv []Timeval) error { 82 if len(tv) != 2 { 83 return EINVAL 84 } 85 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 86 } 87 88 //sys utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) 89 func UtimesNano(path string, ts []Timespec) error { 90 if len(ts) != 2 { 91 return EINVAL 92 } 93 return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 94 } 95 96 //sys unlinkat(dirfd int, path string, flags int) (err error) 97 func Unlinkat(dirfd int, path string) (err error) { 98 return unlinkat(dirfd, path, 0) 99 } 100 101 //sys getcwd(buf *byte, size uint64) (err error) 102 103 const ImplementsGetwd = true 104 105 func Getwd() (ret string, err error) { 106 for len := uint64(4096); ; len *= 2 { 107 b := make([]byte, len) 108 err := getcwd(&b[0], len) 109 if err == nil { 110 i := 0 111 for b[i] != 0 { 112 i++ 113 } 114 return string(b[0:i]), nil 115 } 116 if err != ERANGE { 117 return "", err 118 } 119 } 120 } 121 122 func Getcwd(buf []byte) (n int, err error) { 123 err = getcwd(&buf[0], uint64(len(buf))) 124 if err == nil { 125 i := 0 126 for buf[i] != 0 { 127 i++ 128 } 129 n = i + 1 130 } 131 return 132 } 133 134 //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) 135 //sysnb setgroups(ngid int, gid *_Gid_t) (err error) 136 137 func Getgroups() (gids []int, err error) { 138 n, err := getgroups(0, nil) 139 if err != nil { 140 return nil, err 141 } 142 if n == 0 { 143 return nil, nil 144 } 145 146 // Sanity check group count. Max is 16 on BSD. 147 if n < 0 || n > 1000 { 148 return nil, EINVAL 149 } 150 151 a := make([]_Gid_t, n) 152 n, err = getgroups(n, &a[0]) 153 if err != nil { 154 return nil, err 155 } 156 gids = make([]int, n) 157 for i, v := range a[0:n] { 158 gids[i] = int(v) 159 } 160 return 161 } 162 163 func Setgroups(gids []int) (err error) { 164 if len(gids) == 0 { 165 return setgroups(0, nil) 166 } 167 168 a := make([]_Gid_t, len(gids)) 169 for i, v := range gids { 170 a[i] = _Gid_t(v) 171 } 172 return setgroups(len(a), &a[0]) 173 } 174 175 func direntIno(buf []byte) (uint64, bool) { 176 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) 177 } 178 179 func direntReclen(buf []byte) (uint64, bool) { 180 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) 181 } 182 183 func direntNamlen(buf []byte) (uint64, bool) { 184 reclen, ok := direntReclen(buf) 185 if !ok { 186 return 0, false 187 } 188 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true 189 } 190 191 func Gettimeofday(tv *Timeval) (err error) { 192 err = gettimeofday(tv, nil) 193 return 194 } 195 196 // TODO 197 func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { 198 return -1, ENOSYS 199 } 200 201 //sys getdirent(fd int, buf []byte) (n int, err error) 202 func ReadDirent(fd int, buf []byte) (n int, err error) { 203 return getdirent(fd, buf) 204 } 205 206 //sys wait4(pid _Pid_t, status *_C_int, options int, rusage *Rusage) (wpid _Pid_t, err error) 207 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { 208 var status _C_int 209 var r _Pid_t 210 err = ERESTART 211 // AIX wait4 may return with ERESTART errno, while the processus is still 212 // active. 213 for err == ERESTART { 214 r, err = wait4(_Pid_t(pid), &status, options, rusage) 215 } 216 wpid = int(r) 217 if wstatus != nil { 218 *wstatus = WaitStatus(status) 219 } 220 return 221 } 222 223 //sys fsyncRange(fd int, how int, start int64, length int64) (err error) = fsync_range 224 func Fsync(fd int) error { 225 return fsyncRange(fd, O_SYNC, 0, 0) 226 } 227 228 /* 229 * Socket 230 */ 231 //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) 232 //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) 233 //sys Getkerninfo(op int32, where uintptr, size uintptr, arg int64) (i int32, err error) 234 //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) 235 //sys Listen(s int, backlog int) (err error) 236 //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) 237 //sys socket(domain int, typ int, proto int) (fd int, err error) 238 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) 239 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) 240 //sys getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) 241 //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) 242 //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) 243 //sys Shutdown(s int, how int) (err error) 244 245 // In order to use msghdr structure with Control, Controllen in golang.org/x/net, 246 // nrecvmsg and nsendmsg must be used. 247 //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = nrecvmsg 248 //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = nsendmsg 249 250 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { 251 if sa.Port < 0 || sa.Port > 0xFFFF { 252 return nil, 0, EINVAL 253 } 254 sa.raw.Family = AF_INET 255 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 256 p[0] = byte(sa.Port >> 8) 257 p[1] = byte(sa.Port) 258 for i := 0; i < len(sa.Addr); i++ { 259 sa.raw.Addr[i] = sa.Addr[i] 260 } 261 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil 262 } 263 264 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { 265 if sa.Port < 0 || sa.Port > 0xFFFF { 266 return nil, 0, EINVAL 267 } 268 sa.raw.Family = AF_INET6 269 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 270 p[0] = byte(sa.Port >> 8) 271 p[1] = byte(sa.Port) 272 sa.raw.Scope_id = sa.ZoneId 273 for i := 0; i < len(sa.Addr); i++ { 274 sa.raw.Addr[i] = sa.Addr[i] 275 } 276 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil 277 } 278 279 func (sa *RawSockaddrUnix) setLen(n int) { 280 sa.Len = uint8(3 + n) // 2 for Family, Len; 1 for NUL. 281 } 282 283 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { 284 name := sa.Name 285 n := len(name) 286 if n > len(sa.raw.Path) { 287 return nil, 0, EINVAL 288 } 289 sa.raw.Family = AF_UNIX 290 sa.raw.setLen(n) 291 for i := 0; i < n; i++ { 292 sa.raw.Path[i] = uint8(name[i]) 293 } 294 // length is family (uint16), name, NUL. 295 sl := _Socklen(2) 296 if n > 0 { 297 sl += _Socklen(n) + 1 298 } 299 300 return unsafe.Pointer(&sa.raw), sl, nil 301 } 302 303 func Getsockname(fd int) (sa Sockaddr, err error) { 304 var rsa RawSockaddrAny 305 var len _Socklen = SizeofSockaddrAny 306 if err = getsockname(fd, &rsa, &len); err != nil { 307 return 308 } 309 return anyToSockaddr(&rsa) 310 } 311 312 //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) 313 func Accept(fd int) (nfd int, sa Sockaddr, err error) { 314 var rsa RawSockaddrAny 315 var len _Socklen = SizeofSockaddrAny 316 nfd, err = accept(fd, &rsa, &len) 317 if err != nil { 318 return 319 } 320 sa, err = anyToSockaddr(&rsa) 321 if err != nil { 322 Close(nfd) 323 nfd = 0 324 } 325 return 326 } 327 328 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 329 var msg Msghdr 330 var rsa RawSockaddrAny 331 msg.Name = (*byte)(unsafe.Pointer(&rsa)) 332 msg.Namelen = uint32(SizeofSockaddrAny) 333 var iov Iovec 334 if len(p) > 0 { 335 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 336 iov.SetLen(len(p)) 337 } 338 var dummy byte 339 if len(oob) > 0 { 340 var sockType int 341 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 342 if err != nil { 343 return 344 } 345 // receive at least one normal byte 346 if sockType != SOCK_DGRAM && len(p) == 0 { 347 iov.Base = &dummy 348 iov.SetLen(1) 349 } 350 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 351 msg.SetControllen(len(oob)) 352 } 353 msg.Iov = &iov 354 msg.Iovlen = 1 355 if n, err = recvmsg(fd, &msg, flags); err != nil { 356 return 357 } 358 oobn = int(msg.Controllen) 359 recvflags = int(msg.Flags) 360 // source address is only specified if the socket is unconnected 361 if rsa.Addr.Family != AF_UNSPEC { 362 from, err = anyToSockaddr(&rsa) 363 } 364 return 365 } 366 367 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { 368 _, err = SendmsgN(fd, p, oob, to, flags) 369 return 370 } 371 372 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { 373 var ptr unsafe.Pointer 374 var salen _Socklen 375 if to != nil { 376 ptr, salen, err = to.sockaddr() 377 if err != nil { 378 return 0, err 379 } 380 } 381 var msg Msghdr 382 msg.Name = (*byte)(unsafe.Pointer(ptr)) 383 msg.Namelen = uint32(salen) 384 var iov Iovec 385 if len(p) > 0 { 386 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 387 iov.SetLen(len(p)) 388 } 389 var dummy byte 390 if len(oob) > 0 { 391 var sockType int 392 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 393 if err != nil { 394 return 0, err 395 } 396 // send at least one normal byte 397 if sockType != SOCK_DGRAM && len(p) == 0 { 398 iov.Base = &dummy 399 iov.SetLen(1) 400 } 401 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 402 msg.SetControllen(len(oob)) 403 } 404 msg.Iov = &iov 405 msg.Iovlen = 1 406 if n, err = sendmsg(fd, &msg, flags); err != nil { 407 return 0, err 408 } 409 if len(oob) > 0 && len(p) == 0 { 410 n = 0 411 } 412 return n, nil 413 } 414 415 func (sa *RawSockaddrUnix) getLen() (int, error) { 416 // Some versions of AIX have a bug in getsockname (see IV78655). 417 // We can't rely on sa.Len being set correctly. 418 n := SizeofSockaddrUnix - 3 // subtract leading Family, Len, terminating NUL. 419 for i := 0; i < n; i++ { 420 if sa.Path[i] == 0 { 421 n = i 422 break 423 } 424 } 425 return n, nil 426 } 427 428 func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { 429 switch rsa.Addr.Family { 430 case AF_UNIX: 431 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) 432 sa := new(SockaddrUnix) 433 n, err := pp.getLen() 434 if err != nil { 435 return nil, err 436 } 437 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0])) 438 sa.Name = string(bytes[0:n]) 439 return sa, nil 440 441 case AF_INET: 442 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 443 sa := new(SockaddrInet4) 444 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 445 sa.Port = int(p[0])<<8 + int(p[1]) 446 for i := 0; i < len(sa.Addr); i++ { 447 sa.Addr[i] = pp.Addr[i] 448 } 449 return sa, nil 450 451 case AF_INET6: 452 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 453 sa := new(SockaddrInet6) 454 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 455 sa.Port = int(p[0])<<8 + int(p[1]) 456 for i := 0; i < len(sa.Addr); i++ { 457 sa.Addr[i] = pp.Addr[i] 458 } 459 return sa, nil 460 } 461 return nil, EAFNOSUPPORT 462 } 463 464 type SockaddrDatalink struct { 465 Len uint8 466 Family uint8 467 Index uint16 468 Type uint8 469 Nlen uint8 470 Alen uint8 471 Slen uint8 472 Data [120]uint8 473 raw RawSockaddrDatalink 474 } 475 476 /* 477 * Wait 478 */ 479 480 type WaitStatus uint32 481 482 func (w WaitStatus) Stopped() bool { return w&0x40 != 0 } 483 func (w WaitStatus) StopSignal() Signal { 484 if !w.Stopped() { 485 return -1 486 } 487 return Signal(w>>8) & 0xFF 488 } 489 490 func (w WaitStatus) Exited() bool { return w&0xFF == 0 } 491 func (w WaitStatus) ExitStatus() int { 492 if !w.Exited() { 493 return -1 494 } 495 return int((w >> 8) & 0xFF) 496 } 497 498 func (w WaitStatus) Signaled() bool { return w&0x40 == 0 && w&0xFF != 0 } 499 func (w WaitStatus) Signal() Signal { 500 if !w.Signaled() { 501 return -1 502 } 503 return Signal(w>>16) & 0xFF 504 } 505 506 func (w WaitStatus) Continued() bool { return w&0x01000000 != 0 } 507 508 func (w WaitStatus) CoreDump() bool { return w&0x80 == 0x80 } 509 510 func (w WaitStatus) TrapCause() int { return -1 } 511 512 /* 513 * ptrace 514 */ 515 516 //sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) 517 //sys ptrace64(request int, id int64, addr int64, data int, buff uintptr) (err error) 518 519 func raw_ptrace(request int, pid int, addr *byte, data *byte) Errno { 520 if request == PTRACE_TRACEME { 521 // Convert to AIX ptrace call. 522 err := ptrace64(PT_TRACE_ME, 0, 0, 0, 0) 523 if err != nil { 524 return err.(Errno) 525 } 526 return 0 527 } 528 return ENOSYS 529 } 530 531 func ptracePeek(pid int, addr uintptr, out []byte) (count int, err error) { 532 n := 0 533 for len(out) > 0 { 534 bsize := len(out) 535 if bsize > 1024 { 536 bsize = 1024 537 } 538 err = ptrace64(PT_READ_BLOCK, int64(pid), int64(addr), bsize, uintptr(unsafe.Pointer(&out[0]))) 539 if err != nil { 540 return 0, err 541 } 542 addr += uintptr(bsize) 543 n += bsize 544 out = out[n:] 545 } 546 return n, nil 547 } 548 549 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) { 550 return ptracePeek(pid, addr, out) 551 } 552 553 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) { 554 return ptracePeek(pid, addr, out) 555 } 556 557 func ptracePoke(pid int, addr uintptr, data []byte) (count int, err error) { 558 n := 0 559 for len(data) > 0 { 560 bsize := len(data) 561 if bsize > 1024 { 562 bsize = 1024 563 } 564 err = ptrace64(PT_WRITE_BLOCK, int64(pid), int64(addr), bsize, uintptr(unsafe.Pointer(&data[0]))) 565 if err != nil { 566 return 0, err 567 } 568 addr += uintptr(bsize) 569 n += bsize 570 data = data[n:] 571 } 572 return n, nil 573 } 574 575 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) { 576 return ptracePoke(pid, addr, data) 577 } 578 579 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) { 580 return ptracePoke(pid, addr, data) 581 } 582 583 func PtraceCont(pid int, signal int) (err error) { 584 return ptrace64(PT_CONTINUE, int64(pid), 1, signal, 0) 585 } 586 587 func PtraceSingleStep(pid int) (err error) { return ptrace64(PT_STEP, int64(pid), 1, 0, 0) } 588 589 func PtraceAttach(pid int) (err error) { return ptrace64(PT_ATTACH, int64(pid), 0, 0, 0) } 590 591 func PtraceDetach(pid int) (err error) { return ptrace64(PT_DETACH, int64(pid), 0, 0, 0) } 592 593 /* 594 * Direct access 595 */ 596 597 //sys Acct(path string) (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 Dup(fd int) (nfd int, err error) 604 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) 605 //sys Fchdir(fd int) (err error) 606 //sys Fchmod(fd int, mode uint32) (err error) 607 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) 608 //sys Fchown(fd int, uid int, gid int) (err error) 609 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) 610 //sys Fpathconf(fd int, name int) (val int, err error) 611 //sys Fstat(fd int, stat *Stat_t) (err error) 612 //sys Fstatfs(fd int, buf *Statfs_t) (err error) 613 //sys Ftruncate(fd int, length int64) (err error) 614 //sysnb Getgid() (gid int) 615 //sysnb Getpid() (pid int) 616 //sys Geteuid() (euid int) 617 //sys Getegid() (egid int) 618 //sys Getppid() (ppid int) 619 //sys Getpriority(which int, who int) (n int, err error) 620 //sysnb Getrlimit(which int, lim *Rlimit) (err error) 621 //sysnb Getuid() (uid int) 622 //sys Kill(pid int, signum Signal) (err error) 623 //sys Lchown(path string, uid int, gid int) (err error) 624 //sys Link(path string, link string) (err error) 625 //sys Lstat(path string, stat *Stat_t) (err error) 626 //sys Mkdir(path string, mode uint32) (err error) 627 //sys Mkdirat(dirfd int, path string, mode uint32) (err error) 628 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) 629 //sys Open(path string, mode int, perm uint32) (fd int, err error) 630 //sys Pread(fd int, p []byte, offset int64) (n int, err error) 631 //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) 632 //sys read(fd int, p []byte) (n int, err error) 633 //sys Reboot(how int) (err error) 634 //sys Rename(from string, to string) (err error) 635 //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) 636 //sys Rmdir(path string) (err error) 637 //sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek 638 //sysnb Setegid(egid int) (err error) 639 //sysnb Seteuid(euid int) (err error) 640 //sysnb Setgid(gid int) (err error) 641 //sysnb Setpgid(pid int, pgid int) (err error) 642 //sys Setpriority(which int, who int, prio int) (err error) 643 //sysnb Setregid(rgid int, egid int) (err error) 644 //sysnb Setreuid(ruid int, euid int) (err error) 645 //sysnb Setrlimit(which int, lim *Rlimit) (err error) 646 //sys Stat(path string, stat *Stat_t) (err error) 647 //sys Statfs(path string, buf *Statfs_t) (err error) 648 //sys Symlink(path string, link string) (err error) 649 //sys Truncate(path string, length int64) (err error) 650 //sys Umask(newmask int) (oldmask int) 651 //sys Unlink(path string) (err error) 652 //sysnb Uname(buf *Utsname) (err error) 653 //sys write(fd int, p []byte) (n int, err error) 654 655 //sys gettimeofday(tv *Timeval, tzp *Timezone) (err error) 656 657 func setTimespec(sec, nsec int64) Timespec { 658 return Timespec{Sec: sec, Nsec: nsec} 659 } 660 661 func setTimeval(sec, usec int64) Timeval { 662 return Timeval{Sec: sec, Usec: int32(usec)} 663 } 664 665 func readlen(fd int, buf *byte, nbuf int) (n int, err error) { 666 r0, _, e1 := syscall6(uintptr(unsafe.Pointer(&libc_read)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0) 667 n = int(r0) 668 if e1 != 0 { 669 err = e1 670 } 671 return 672 } 673 674 /* 675 * Map 676 */ 677 678 var mapper = &mmapper{ 679 active: make(map[*byte][]byte), 680 mmap: mmap, 681 munmap: munmap, 682 } 683 684 //sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) 685 //sys munmap(addr uintptr, length uintptr) (err error) 686 687 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 688 return mapper.Mmap(fd, offset, length, prot, flags) 689 } 690 691 func Munmap(b []byte) (err error) { 692 return mapper.Munmap(b) 693 }