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