github.com/maenmax/kairep@v0.0.0-20210218001208-55bf3df36788/src/golang.org/x/sys/unix/syscall_linux.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 // Linux 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 unix 13 14 import ( 15 "syscall" 16 "unsafe" 17 ) 18 19 /* 20 * Wrapped 21 */ 22 23 func Access(path string, mode uint32) (err error) { 24 return Faccessat(AT_FDCWD, path, mode, 0) 25 } 26 27 func Chmod(path string, mode uint32) (err error) { 28 return Fchmodat(AT_FDCWD, path, mode, 0) 29 } 30 31 func Chown(path string, uid int, gid int) (err error) { 32 return Fchownat(AT_FDCWD, path, uid, gid, 0) 33 } 34 35 func Creat(path string, mode uint32) (fd int, err error) { 36 return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode) 37 } 38 39 //sys Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error) 40 41 func Link(oldpath string, newpath string) (err error) { 42 return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0) 43 } 44 45 func Mkdir(path string, mode uint32) (err error) { 46 return Mkdirat(AT_FDCWD, path, mode) 47 } 48 49 func Mknod(path string, mode uint32, dev int) (err error) { 50 return Mknodat(AT_FDCWD, path, mode, dev) 51 } 52 53 func Open(path string, mode int, perm uint32) (fd int, err error) { 54 return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm) 55 } 56 57 //sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) 58 59 func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { 60 return openat(dirfd, path, flags|O_LARGEFILE, mode) 61 } 62 63 //sys ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) 64 65 func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { 66 if len(fds) == 0 { 67 return ppoll(nil, 0, timeout, sigmask) 68 } 69 return ppoll(&fds[0], len(fds), timeout, sigmask) 70 } 71 72 //sys readlinkat(dirfd int, path string, buf []byte) (n int, err error) 73 74 func Readlink(path string, buf []byte) (n int, err error) { 75 return readlinkat(AT_FDCWD, path, buf) 76 } 77 78 func Rename(oldpath string, newpath string) (err error) { 79 return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath) 80 } 81 82 func Rmdir(path string) error { 83 return unlinkat(AT_FDCWD, path, AT_REMOVEDIR) 84 } 85 86 //sys symlinkat(oldpath string, newdirfd int, newpath string) (err error) 87 88 func Symlink(oldpath string, newpath string) (err error) { 89 return symlinkat(oldpath, AT_FDCWD, newpath) 90 } 91 92 func Unlink(path string) error { 93 return unlinkat(AT_FDCWD, path, 0) 94 } 95 96 //sys unlinkat(dirfd int, path string, flags int) (err error) 97 98 func Unlinkat(dirfd int, path string, flags int) error { 99 return unlinkat(dirfd, path, flags) 100 } 101 102 //sys utimes(path string, times *[2]Timeval) (err error) 103 104 func Utimes(path string, tv []Timeval) error { 105 if tv == nil { 106 err := utimensat(AT_FDCWD, path, nil, 0) 107 if err != ENOSYS { 108 return err 109 } 110 return utimes(path, nil) 111 } 112 if len(tv) != 2 { 113 return EINVAL 114 } 115 var ts [2]Timespec 116 ts[0] = NsecToTimespec(TimevalToNsec(tv[0])) 117 ts[1] = NsecToTimespec(TimevalToNsec(tv[1])) 118 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 119 if err != ENOSYS { 120 return err 121 } 122 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 123 } 124 125 //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) 126 127 func UtimesNano(path string, ts []Timespec) error { 128 if ts == nil { 129 err := utimensat(AT_FDCWD, path, nil, 0) 130 if err != ENOSYS { 131 return err 132 } 133 return utimes(path, nil) 134 } 135 if len(ts) != 2 { 136 return EINVAL 137 } 138 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 139 if err != ENOSYS { 140 return err 141 } 142 // If the utimensat syscall isn't available (utimensat was added to Linux 143 // in 2.6.22, Released, 8 July 2007) then fall back to utimes 144 var tv [2]Timeval 145 for i := 0; i < 2; i++ { 146 tv[i].Sec = ts[i].Sec 147 tv[i].Usec = ts[i].Nsec / 1000 148 } 149 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 150 } 151 152 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { 153 if ts == nil { 154 return utimensat(dirfd, path, nil, flags) 155 } 156 if len(ts) != 2 { 157 return EINVAL 158 } 159 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) 160 } 161 162 //sys futimesat(dirfd int, path *byte, times *[2]Timeval) (err error) 163 164 func Futimesat(dirfd int, path string, tv []Timeval) error { 165 pathp, err := BytePtrFromString(path) 166 if err != nil { 167 return err 168 } 169 if tv == nil { 170 return futimesat(dirfd, pathp, nil) 171 } 172 if len(tv) != 2 { 173 return EINVAL 174 } 175 return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 176 } 177 178 func Futimes(fd int, tv []Timeval) (err error) { 179 // Believe it or not, this is the best we can do on Linux 180 // (and is what glibc does). 181 return Utimes("/proc/self/fd/"+itoa(fd), tv) 182 } 183 184 const ImplementsGetwd = true 185 186 //sys Getcwd(buf []byte) (n int, err error) 187 188 func Getwd() (wd string, err error) { 189 var buf [PathMax]byte 190 n, err := Getcwd(buf[0:]) 191 if err != nil { 192 return "", err 193 } 194 // Getcwd returns the number of bytes written to buf, including the NUL. 195 if n < 1 || n > len(buf) || buf[n-1] != 0 { 196 return "", EINVAL 197 } 198 return string(buf[0 : n-1]), nil 199 } 200 201 func Getgroups() (gids []int, err error) { 202 n, err := getgroups(0, nil) 203 if err != nil { 204 return nil, err 205 } 206 if n == 0 { 207 return nil, nil 208 } 209 210 // Sanity check group count. Max is 1<<16 on Linux. 211 if n < 0 || n > 1<<20 { 212 return nil, EINVAL 213 } 214 215 a := make([]_Gid_t, n) 216 n, err = getgroups(n, &a[0]) 217 if err != nil { 218 return nil, err 219 } 220 gids = make([]int, n) 221 for i, v := range a[0:n] { 222 gids[i] = int(v) 223 } 224 return 225 } 226 227 func Setgroups(gids []int) (err error) { 228 if len(gids) == 0 { 229 return setgroups(0, nil) 230 } 231 232 a := make([]_Gid_t, len(gids)) 233 for i, v := range gids { 234 a[i] = _Gid_t(v) 235 } 236 return setgroups(len(a), &a[0]) 237 } 238 239 type WaitStatus uint32 240 241 // Wait status is 7 bits at bottom, either 0 (exited), 242 // 0x7F (stopped), or a signal number that caused an exit. 243 // The 0x80 bit is whether there was a core dump. 244 // An extra number (exit code, signal causing a stop) 245 // is in the high bits. At least that's the idea. 246 // There are various irregularities. For example, the 247 // "continued" status is 0xFFFF, distinguishing itself 248 // from stopped via the core dump bit. 249 250 const ( 251 mask = 0x7F 252 core = 0x80 253 exited = 0x00 254 stopped = 0x7F 255 shift = 8 256 ) 257 258 func (w WaitStatus) Exited() bool { return w&mask == exited } 259 260 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited } 261 262 func (w WaitStatus) Stopped() bool { return w&0xFF == stopped } 263 264 func (w WaitStatus) Continued() bool { return w == 0xFFFF } 265 266 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } 267 268 func (w WaitStatus) ExitStatus() int { 269 if !w.Exited() { 270 return -1 271 } 272 return int(w>>shift) & 0xFF 273 } 274 275 func (w WaitStatus) Signal() syscall.Signal { 276 if !w.Signaled() { 277 return -1 278 } 279 return syscall.Signal(w & mask) 280 } 281 282 func (w WaitStatus) StopSignal() syscall.Signal { 283 if !w.Stopped() { 284 return -1 285 } 286 return syscall.Signal(w>>shift) & 0xFF 287 } 288 289 func (w WaitStatus) TrapCause() int { 290 if w.StopSignal() != SIGTRAP { 291 return -1 292 } 293 return int(w>>shift) >> 8 294 } 295 296 //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) 297 298 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { 299 var status _C_int 300 wpid, err = wait4(pid, &status, options, rusage) 301 if wstatus != nil { 302 *wstatus = WaitStatus(status) 303 } 304 return 305 } 306 307 func Mkfifo(path string, mode uint32) (err error) { 308 return Mknod(path, mode|S_IFIFO, 0) 309 } 310 311 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { 312 if sa.Port < 0 || sa.Port > 0xFFFF { 313 return nil, 0, EINVAL 314 } 315 sa.raw.Family = AF_INET 316 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 317 p[0] = byte(sa.Port >> 8) 318 p[1] = byte(sa.Port) 319 for i := 0; i < len(sa.Addr); i++ { 320 sa.raw.Addr[i] = sa.Addr[i] 321 } 322 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil 323 } 324 325 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { 326 if sa.Port < 0 || sa.Port > 0xFFFF { 327 return nil, 0, EINVAL 328 } 329 sa.raw.Family = AF_INET6 330 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 331 p[0] = byte(sa.Port >> 8) 332 p[1] = byte(sa.Port) 333 sa.raw.Scope_id = sa.ZoneId 334 for i := 0; i < len(sa.Addr); i++ { 335 sa.raw.Addr[i] = sa.Addr[i] 336 } 337 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil 338 } 339 340 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { 341 name := sa.Name 342 n := len(name) 343 if n >= len(sa.raw.Path) { 344 return nil, 0, EINVAL 345 } 346 sa.raw.Family = AF_UNIX 347 for i := 0; i < n; i++ { 348 sa.raw.Path[i] = int8(name[i]) 349 } 350 // length is family (uint16), name, NUL. 351 sl := _Socklen(2) 352 if n > 0 { 353 sl += _Socklen(n) + 1 354 } 355 if sa.raw.Path[0] == '@' { 356 sa.raw.Path[0] = 0 357 // Don't count trailing NUL for abstract address. 358 sl-- 359 } 360 361 return unsafe.Pointer(&sa.raw), sl, nil 362 } 363 364 type SockaddrLinklayer struct { 365 Protocol uint16 366 Ifindex int 367 Hatype uint16 368 Pkttype uint8 369 Halen uint8 370 Addr [8]byte 371 raw RawSockaddrLinklayer 372 } 373 374 func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) { 375 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff { 376 return nil, 0, EINVAL 377 } 378 sa.raw.Family = AF_PACKET 379 sa.raw.Protocol = sa.Protocol 380 sa.raw.Ifindex = int32(sa.Ifindex) 381 sa.raw.Hatype = sa.Hatype 382 sa.raw.Pkttype = sa.Pkttype 383 sa.raw.Halen = sa.Halen 384 for i := 0; i < len(sa.Addr); i++ { 385 sa.raw.Addr[i] = sa.Addr[i] 386 } 387 return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil 388 } 389 390 type SockaddrNetlink struct { 391 Family uint16 392 Pad uint16 393 Pid uint32 394 Groups uint32 395 raw RawSockaddrNetlink 396 } 397 398 func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) { 399 sa.raw.Family = AF_NETLINK 400 sa.raw.Pad = sa.Pad 401 sa.raw.Pid = sa.Pid 402 sa.raw.Groups = sa.Groups 403 return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil 404 } 405 406 type SockaddrHCI struct { 407 Dev uint16 408 Channel uint16 409 raw RawSockaddrHCI 410 } 411 412 func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) { 413 sa.raw.Family = AF_BLUETOOTH 414 sa.raw.Dev = sa.Dev 415 sa.raw.Channel = sa.Channel 416 return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil 417 } 418 419 func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { 420 switch rsa.Addr.Family { 421 case AF_NETLINK: 422 pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa)) 423 sa := new(SockaddrNetlink) 424 sa.Family = pp.Family 425 sa.Pad = pp.Pad 426 sa.Pid = pp.Pid 427 sa.Groups = pp.Groups 428 return sa, nil 429 430 case AF_PACKET: 431 pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa)) 432 sa := new(SockaddrLinklayer) 433 sa.Protocol = pp.Protocol 434 sa.Ifindex = int(pp.Ifindex) 435 sa.Hatype = pp.Hatype 436 sa.Pkttype = pp.Pkttype 437 sa.Halen = pp.Halen 438 for i := 0; i < len(sa.Addr); i++ { 439 sa.Addr[i] = pp.Addr[i] 440 } 441 return sa, nil 442 443 case AF_UNIX: 444 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) 445 sa := new(SockaddrUnix) 446 if pp.Path[0] == 0 { 447 // "Abstract" Unix domain socket. 448 // Rewrite leading NUL as @ for textual display. 449 // (This is the standard convention.) 450 // Not friendly to overwrite in place, 451 // but the callers below don't care. 452 pp.Path[0] = '@' 453 } 454 455 // Assume path ends at NUL. 456 // This is not technically the Linux semantics for 457 // abstract Unix domain sockets--they are supposed 458 // to be uninterpreted fixed-size binary blobs--but 459 // everyone uses this convention. 460 n := 0 461 for n < len(pp.Path) && pp.Path[n] != 0 { 462 n++ 463 } 464 bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] 465 sa.Name = string(bytes) 466 return sa, nil 467 468 case AF_INET: 469 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 470 sa := new(SockaddrInet4) 471 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 472 sa.Port = int(p[0])<<8 + int(p[1]) 473 for i := 0; i < len(sa.Addr); i++ { 474 sa.Addr[i] = pp.Addr[i] 475 } 476 return sa, nil 477 478 case AF_INET6: 479 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 480 sa := new(SockaddrInet6) 481 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 482 sa.Port = int(p[0])<<8 + int(p[1]) 483 sa.ZoneId = pp.Scope_id 484 for i := 0; i < len(sa.Addr); i++ { 485 sa.Addr[i] = pp.Addr[i] 486 } 487 return sa, nil 488 } 489 return nil, EAFNOSUPPORT 490 } 491 492 func Accept(fd int) (nfd int, sa Sockaddr, err error) { 493 var rsa RawSockaddrAny 494 var len _Socklen = SizeofSockaddrAny 495 nfd, err = accept(fd, &rsa, &len) 496 if err != nil { 497 return 498 } 499 sa, err = anyToSockaddr(&rsa) 500 if err != nil { 501 Close(nfd) 502 nfd = 0 503 } 504 return 505 } 506 507 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { 508 var rsa RawSockaddrAny 509 var len _Socklen = SizeofSockaddrAny 510 nfd, err = accept4(fd, &rsa, &len, flags) 511 if err != nil { 512 return 513 } 514 if len > SizeofSockaddrAny { 515 panic("RawSockaddrAny too small") 516 } 517 sa, err = anyToSockaddr(&rsa) 518 if err != nil { 519 Close(nfd) 520 nfd = 0 521 } 522 return 523 } 524 525 func Getsockname(fd int) (sa Sockaddr, err error) { 526 var rsa RawSockaddrAny 527 var len _Socklen = SizeofSockaddrAny 528 if err = getsockname(fd, &rsa, &len); err != nil { 529 return 530 } 531 return anyToSockaddr(&rsa) 532 } 533 534 func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) { 535 vallen := _Socklen(4) 536 err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) 537 return value, err 538 } 539 540 func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) { 541 var value IPMreq 542 vallen := _Socklen(SizeofIPMreq) 543 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 544 return &value, err 545 } 546 547 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) { 548 var value IPMreqn 549 vallen := _Socklen(SizeofIPMreqn) 550 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 551 return &value, err 552 } 553 554 func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) { 555 var value IPv6Mreq 556 vallen := _Socklen(SizeofIPv6Mreq) 557 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 558 return &value, err 559 } 560 561 func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) { 562 var value IPv6MTUInfo 563 vallen := _Socklen(SizeofIPv6MTUInfo) 564 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 565 return &value, err 566 } 567 568 func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) { 569 var value ICMPv6Filter 570 vallen := _Socklen(SizeofICMPv6Filter) 571 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 572 return &value, err 573 } 574 575 func GetsockoptUcred(fd, level, opt int) (*Ucred, error) { 576 var value Ucred 577 vallen := _Socklen(SizeofUcred) 578 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 579 return &value, err 580 } 581 582 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { 583 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) 584 } 585 586 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 587 var msg Msghdr 588 var rsa RawSockaddrAny 589 msg.Name = (*byte)(unsafe.Pointer(&rsa)) 590 msg.Namelen = uint32(SizeofSockaddrAny) 591 var iov Iovec 592 if len(p) > 0 { 593 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 594 iov.SetLen(len(p)) 595 } 596 var dummy byte 597 if len(oob) > 0 { 598 // receive at least one normal byte 599 if len(p) == 0 { 600 iov.Base = &dummy 601 iov.SetLen(1) 602 } 603 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 604 msg.SetControllen(len(oob)) 605 } 606 msg.Iov = &iov 607 msg.Iovlen = 1 608 if n, err = recvmsg(fd, &msg, flags); err != nil { 609 return 610 } 611 oobn = int(msg.Controllen) 612 recvflags = int(msg.Flags) 613 // source address is only specified if the socket is unconnected 614 if rsa.Addr.Family != AF_UNSPEC { 615 from, err = anyToSockaddr(&rsa) 616 } 617 return 618 } 619 620 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { 621 _, err = SendmsgN(fd, p, oob, to, flags) 622 return 623 } 624 625 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { 626 var ptr unsafe.Pointer 627 var salen _Socklen 628 if to != nil { 629 var err error 630 ptr, salen, err = to.sockaddr() 631 if err != nil { 632 return 0, err 633 } 634 } 635 var msg Msghdr 636 msg.Name = (*byte)(unsafe.Pointer(ptr)) 637 msg.Namelen = uint32(salen) 638 var iov Iovec 639 if len(p) > 0 { 640 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 641 iov.SetLen(len(p)) 642 } 643 var dummy byte 644 if len(oob) > 0 { 645 // send at least one normal byte 646 if len(p) == 0 { 647 iov.Base = &dummy 648 iov.SetLen(1) 649 } 650 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 651 msg.SetControllen(len(oob)) 652 } 653 msg.Iov = &iov 654 msg.Iovlen = 1 655 if n, err = sendmsg(fd, &msg, flags); err != nil { 656 return 0, err 657 } 658 if len(oob) > 0 && len(p) == 0 { 659 n = 0 660 } 661 return n, nil 662 } 663 664 // BindToDevice binds the socket associated with fd to device. 665 func BindToDevice(fd int, device string) (err error) { 666 return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device) 667 } 668 669 //sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error) 670 671 func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) { 672 // The peek requests are machine-size oriented, so we wrap it 673 // to retrieve arbitrary-length data. 674 675 // The ptrace syscall differs from glibc's ptrace. 676 // Peeks returns the word in *data, not as the return value. 677 678 var buf [sizeofPtr]byte 679 680 // Leading edge. PEEKTEXT/PEEKDATA don't require aligned 681 // access (PEEKUSER warns that it might), but if we don't 682 // align our reads, we might straddle an unmapped page 683 // boundary and not get the bytes leading up to the page 684 // boundary. 685 n := 0 686 if addr%sizeofPtr != 0 { 687 err = ptrace(req, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 688 if err != nil { 689 return 0, err 690 } 691 n += copy(out, buf[addr%sizeofPtr:]) 692 out = out[n:] 693 } 694 695 // Remainder. 696 for len(out) > 0 { 697 // We use an internal buffer to guarantee alignment. 698 // It's not documented if this is necessary, but we're paranoid. 699 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 700 if err != nil { 701 return n, err 702 } 703 copied := copy(out, buf[0:]) 704 n += copied 705 out = out[copied:] 706 } 707 708 return n, nil 709 } 710 711 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) { 712 return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out) 713 } 714 715 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) { 716 return ptracePeek(PTRACE_PEEKDATA, pid, addr, out) 717 } 718 719 func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) { 720 // As for ptracePeek, we need to align our accesses to deal 721 // with the possibility of straddling an invalid page. 722 723 // Leading edge. 724 n := 0 725 if addr%sizeofPtr != 0 { 726 var buf [sizeofPtr]byte 727 err = ptrace(peekReq, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 728 if err != nil { 729 return 0, err 730 } 731 n += copy(buf[addr%sizeofPtr:], data) 732 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 733 err = ptrace(pokeReq, pid, addr-addr%sizeofPtr, word) 734 if err != nil { 735 return 0, err 736 } 737 data = data[n:] 738 } 739 740 // Interior. 741 for len(data) > sizeofPtr { 742 word := *((*uintptr)(unsafe.Pointer(&data[0]))) 743 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 744 if err != nil { 745 return n, err 746 } 747 n += sizeofPtr 748 data = data[sizeofPtr:] 749 } 750 751 // Trailing edge. 752 if len(data) > 0 { 753 var buf [sizeofPtr]byte 754 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 755 if err != nil { 756 return n, err 757 } 758 copy(buf[0:], data) 759 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 760 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 761 if err != nil { 762 return n, err 763 } 764 n += len(data) 765 } 766 767 return n, nil 768 } 769 770 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) { 771 return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data) 772 } 773 774 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) { 775 return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data) 776 } 777 778 func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) { 779 return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout))) 780 } 781 782 func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) { 783 return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs))) 784 } 785 786 func PtraceSetOptions(pid int, options int) (err error) { 787 return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options)) 788 } 789 790 func PtraceGetEventMsg(pid int) (msg uint, err error) { 791 var data _C_long 792 err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data))) 793 msg = uint(data) 794 return 795 } 796 797 func PtraceCont(pid int, signal int) (err error) { 798 return ptrace(PTRACE_CONT, pid, 0, uintptr(signal)) 799 } 800 801 func PtraceSyscall(pid int, signal int) (err error) { 802 return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal)) 803 } 804 805 func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) } 806 807 func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) } 808 809 func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) } 810 811 //sys reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) 812 813 func Reboot(cmd int) (err error) { 814 return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "") 815 } 816 817 func clen(n []byte) int { 818 for i := 0; i < len(n); i++ { 819 if n[i] == 0 { 820 return i 821 } 822 } 823 return len(n) 824 } 825 826 func ReadDirent(fd int, buf []byte) (n int, err error) { 827 return Getdents(fd, buf) 828 } 829 830 func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) { 831 origlen := len(buf) 832 count = 0 833 for max != 0 && len(buf) > 0 { 834 dirent := (*Dirent)(unsafe.Pointer(&buf[0])) 835 buf = buf[dirent.Reclen:] 836 if dirent.Ino == 0 { // File absent in directory. 837 continue 838 } 839 bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0])) 840 var name = string(bytes[0:clen(bytes[:])]) 841 if name == "." || name == ".." { // Useless names 842 continue 843 } 844 max-- 845 count++ 846 names = append(names, name) 847 } 848 return origlen - len(buf), count, names 849 } 850 851 //sys mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) 852 853 func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { 854 // Certain file systems get rather angry and EINVAL if you give 855 // them an empty string of data, rather than NULL. 856 if data == "" { 857 return mount(source, target, fstype, flags, nil) 858 } 859 datap, err := BytePtrFromString(data) 860 if err != nil { 861 return err 862 } 863 return mount(source, target, fstype, flags, datap) 864 } 865 866 // Sendto 867 // Recvfrom 868 // Socketpair 869 870 /* 871 * Direct access 872 */ 873 //sys Acct(path string) (err error) 874 //sys Adjtimex(buf *Timex) (state int, err error) 875 //sys Chdir(path string) (err error) 876 //sys Chroot(path string) (err error) 877 //sys ClockGettime(clockid int32, time *Timespec) (err error) 878 //sys Close(fd int) (err error) 879 //sys Dup(oldfd int) (fd int, err error) 880 //sys Dup3(oldfd int, newfd int, flags int) (err error) 881 //sysnb EpollCreate(size int) (fd int, err error) 882 //sysnb EpollCreate1(flag int) (fd int, err error) 883 //sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) 884 //sys Exit(code int) = SYS_EXIT_GROUP 885 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) 886 //sys Fallocate(fd int, mode uint32, off int64, len int64) (err error) 887 //sys Fchdir(fd int) (err error) 888 //sys Fchmod(fd int, mode uint32) (err error) 889 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) 890 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) 891 //sys fcntl(fd int, cmd int, arg int) (val int, err error) 892 //sys Fdatasync(fd int) (err error) 893 //sys Flock(fd int, how int) (err error) 894 //sys Fsync(fd int) (err error) 895 //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64 896 //sysnb Getpgid(pid int) (pgid int, err error) 897 898 func Getpgrp() (pid int) { 899 pid, _ = Getpgid(0) 900 return 901 } 902 903 //sysnb Getpid() (pid int) 904 //sysnb Getppid() (ppid int) 905 //sys Getpriority(which int, who int) (prio int, err error) 906 //sysnb Getrusage(who int, rusage *Rusage) (err error) 907 //sysnb Gettid() (tid int) 908 //sys Getxattr(path string, attr string, dest []byte) (sz int, err error) 909 //sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) 910 //sysnb InotifyInit1(flags int) (fd int, err error) 911 //sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) 912 //sysnb Kill(pid int, sig syscall.Signal) (err error) 913 //sys Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG 914 //sys Listxattr(path string, dest []byte) (sz int, err error) 915 //sys Mkdirat(dirfd int, path string, mode uint32) (err error) 916 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) 917 //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) 918 //sys PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT 919 //sysnb prlimit(pid int, resource int, old *Rlimit, newlimit *Rlimit) (err error) = SYS_PRLIMIT64 920 //sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) 921 //sys read(fd int, p []byte) (n int, err error) 922 //sys Removexattr(path string, attr string) (err error) 923 //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) 924 //sys Setdomainname(p []byte) (err error) 925 //sys Sethostname(p []byte) (err error) 926 //sysnb Setpgid(pid int, pgid int) (err error) 927 //sysnb Setsid() (pid int, err error) 928 //sysnb Settimeofday(tv *Timeval) (err error) 929 //sys Setns(fd int, nstype int) (err error) 930 931 // issue 1435. 932 // On linux Setuid and Setgid only affects the current thread, not the process. 933 // This does not match what most callers expect so we must return an error 934 // here rather than letting the caller think that the call succeeded. 935 936 func Setuid(uid int) (err error) { 937 return EOPNOTSUPP 938 } 939 940 func Setgid(uid int) (err error) { 941 return EOPNOTSUPP 942 } 943 944 //sys Setpriority(which int, who int, prio int) (err error) 945 //sys Setxattr(path string, attr string, data []byte, flags int) (err error) 946 //sys Sync() 947 //sysnb Sysinfo(info *Sysinfo_t) (err error) 948 //sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error) 949 //sysnb Tgkill(tgid int, tid int, sig syscall.Signal) (err error) 950 //sysnb Times(tms *Tms) (ticks uintptr, err error) 951 //sysnb Umask(mask int) (oldmask int) 952 //sysnb Uname(buf *Utsname) (err error) 953 //sys Unmount(target string, flags int) (err error) = SYS_UMOUNT2 954 //sys Unshare(flags int) (err error) 955 //sys Ustat(dev int, ubuf *Ustat_t) (err error) 956 //sys write(fd int, p []byte) (n int, err error) 957 //sys exitThread(code int) (err error) = SYS_EXIT 958 //sys readlen(fd int, p *byte, np int) (n int, err error) = SYS_READ 959 //sys writelen(fd int, p *byte, np int) (n int, err error) = SYS_WRITE 960 961 // mmap varies by architecture; see syscall_linux_*.go. 962 //sys munmap(addr uintptr, length uintptr) (err error) 963 964 var mapper = &mmapper{ 965 active: make(map[*byte][]byte), 966 mmap: mmap, 967 munmap: munmap, 968 } 969 970 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 971 return mapper.Mmap(fd, offset, length, prot, flags) 972 } 973 974 func Munmap(b []byte) (err error) { 975 return mapper.Munmap(b) 976 } 977 978 //sys Madvise(b []byte, advice int) (err error) 979 //sys Mprotect(b []byte, prot int) (err error) 980 //sys Mlock(b []byte) (err error) 981 //sys Munlock(b []byte) (err error) 982 //sys Mlockall(flags int) (err error) 983 //sys Munlockall() (err error) 984 985 /* 986 * Unimplemented 987 */ 988 // AddKey 989 // AfsSyscall 990 // Alarm 991 // ArchPrctl 992 // Brk 993 // Capget 994 // Capset 995 // ClockGetres 996 // ClockNanosleep 997 // ClockSettime 998 // Clone 999 // CreateModule 1000 // DeleteModule 1001 // EpollCtlOld 1002 // EpollPwait 1003 // EpollWaitOld 1004 // Eventfd 1005 // Execve 1006 // Fgetxattr 1007 // Flistxattr 1008 // Fork 1009 // Fremovexattr 1010 // Fsetxattr 1011 // Futex 1012 // GetKernelSyms 1013 // GetMempolicy 1014 // GetRobustList 1015 // GetThreadArea 1016 // Getitimer 1017 // Getpmsg 1018 // IoCancel 1019 // IoDestroy 1020 // IoGetevents 1021 // IoSetup 1022 // IoSubmit 1023 // Ioctl 1024 // IoprioGet 1025 // IoprioSet 1026 // KexecLoad 1027 // Keyctl 1028 // Lgetxattr 1029 // Llistxattr 1030 // LookupDcookie 1031 // Lremovexattr 1032 // Lsetxattr 1033 // Mbind 1034 // MigratePages 1035 // Mincore 1036 // ModifyLdt 1037 // Mount 1038 // MovePages 1039 // Mprotect 1040 // MqGetsetattr 1041 // MqNotify 1042 // MqOpen 1043 // MqTimedreceive 1044 // MqTimedsend 1045 // MqUnlink 1046 // Mremap 1047 // Msgctl 1048 // Msgget 1049 // Msgrcv 1050 // Msgsnd 1051 // Msync 1052 // Newfstatat 1053 // Nfsservctl 1054 // Personality 1055 // Pselect6 1056 // Ptrace 1057 // Putpmsg 1058 // QueryModule 1059 // Quotactl 1060 // Readahead 1061 // Readv 1062 // RemapFilePages 1063 // RequestKey 1064 // RestartSyscall 1065 // RtSigaction 1066 // RtSigpending 1067 // RtSigprocmask 1068 // RtSigqueueinfo 1069 // RtSigreturn 1070 // RtSigsuspend 1071 // RtSigtimedwait 1072 // SchedGetPriorityMax 1073 // SchedGetPriorityMin 1074 // SchedGetaffinity 1075 // SchedGetparam 1076 // SchedGetscheduler 1077 // SchedRrGetInterval 1078 // SchedSetaffinity 1079 // SchedSetparam 1080 // SchedYield 1081 // Security 1082 // Semctl 1083 // Semget 1084 // Semop 1085 // Semtimedop 1086 // SetMempolicy 1087 // SetRobustList 1088 // SetThreadArea 1089 // SetTidAddress 1090 // Shmat 1091 // Shmctl 1092 // Shmdt 1093 // Shmget 1094 // Sigaltstack 1095 // Signalfd 1096 // Swapoff 1097 // Swapon 1098 // Sysfs 1099 // TimerCreate 1100 // TimerDelete 1101 // TimerGetoverrun 1102 // TimerGettime 1103 // TimerSettime 1104 // Timerfd 1105 // Tkill (obsolete) 1106 // Tuxcall 1107 // Umount2 1108 // Uselib 1109 // Utimensat 1110 // Vfork 1111 // Vhangup 1112 // Vmsplice 1113 // Vserver 1114 // Waitid 1115 // _Sysctl