libgo/go/syscall/libcall_linux.go

   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 // GNU/Linux library calls.
   6
   7 package syscall
   8
   9 import "unsafe"
  10
  11 //sys   Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
  12 //__go_openat(dirfd _C_int, path *byte, flags _C_int, mode Mode_t) _C_int
  13
  14 //sys   futimesat(dirfd int, path *byte, times *[2]Timeval) (err error)
  15 //futimesat(dirfd _C_int, path *byte, times *[2]Timeval) _C_int
  16 func Futimesat(dirfd int, path string, tv []Timeval) (err error) {
  17         if len(tv) != 2 {
  18                 return EINVAL
  19         }
  20         return futimesat(dirfd, StringBytePtr(path), (*[2]Timeval)(unsafe.Pointer(&tv[0])))
  21 }
  22
  23 func Futimes(fd int, tv []Timeval) (err error) {
  24         // Believe it or not, this is the best we can do on GNU/Linux
  25         // (and is what glibc does).
  26         return Utimes("/proc/self/fd/"+itoa(fd), tv)
  27 }
  28
  29 //sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
  30 //ptrace(request _C_int, pid Pid_t, addr *byte, data *byte) _C_long
  31
  32 //sysnb raw_ptrace(request int, pid int, addr *byte, data *byte) (err Errno)
  33 //ptrace(request _C_int, pid Pid_t, addr *byte, data *byte) _C_long
  34
  35 func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
  36         // The peek requests are machine-size oriented, so we wrap it
  37         // to retrieve arbitrary-length data.
  38
  39         // The ptrace syscall differs from glibc's ptrace.
  40         // Peeks returns the word in *data, not as the return value.
  41
  42         var buf [sizeofPtr]byte
  43
  44         // Leading edge.  PEEKTEXT/PEEKDATA don't require aligned
  45         // access (PEEKUSER warns that it might), but if we don't
  46         // align our reads, we might straddle an unmapped page
  47         // boundary and not get the bytes leading up to the page
  48         // boundary.
  49         n := 0
  50         if addr%sizeofPtr != 0 {
  51                 err = ptrace(req, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
  52                 if err != nil {
  53                         return 0, err
  54                 }
  55                 n += copy(out, buf[addr%sizeofPtr:])
  56                 out = out[n:]
  57         }
  58
  59         // Remainder.
  60         for len(out) > 0 {
  61                 // We use an internal buffer to gaurantee alignment.
  62                 // It's not documented if this is necessary, but we're paranoid.
  63                 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
  64                 if err != nil {
  65                         return n, err
  66                 }
  67                 copied := copy(out, buf[0:])
  68                 n += copied
  69                 out = out[copied:]
  70         }
  71
  72         return n, nil
  73 }
  74
  75 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
  76         return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out)
  77 }
  78
  79 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
  80         return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)
  81 }
  82
  83 func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
  84         // As for ptracePeek, we need to align our accesses to deal
  85         // with the possibility of straddling an invalid page.
  86
  87         // Leading edge.
  88         n := 0
  89         if addr%sizeofPtr != 0 {
  90                 var buf [sizeofPtr]byte
  91                 err = ptrace(peekReq, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
  92                 if err != nil {
  93                         return 0, err
  94                 }
  95                 n += copy(buf[addr%sizeofPtr:], data)
  96                 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
  97                 err = ptrace(pokeReq, pid, addr-addr%sizeofPtr, word)
  98                 if err != nil {
  99                         return 0, err
 100                 }
 101                 data = data[n:]
 102         }
 103
 104         // Interior.
 105         for len(data) > int(sizeofPtr) {
 106                 word := *((*uintptr)(unsafe.Pointer(&data[0])))
 107                 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
 108                 if err != nil {
 109                         return n, err
 110                 }
 111                 n += int(sizeofPtr)
 112                 data = data[sizeofPtr:]
 113         }
 114
 115         // Trailing edge.
 116         if len(data) > 0 {
 117                 var buf [sizeofPtr]byte
 118                 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
 119                 if err != nil {
 120                         return n, err
 121                 }
 122                 copy(buf[0:], data)
 123                 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
 124                 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
 125                 if err != nil {
 126                         return n, err
 127                 }
 128                 n += len(data)
 129         }
 130
 131         return n, nil
 132 }
 133
 134 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
 135         return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data)
 136 }
 137
 138 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
 139         return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)
 140 }
 141
 142 func PtraceSetOptions(pid int, options int) (err error) {
 143         return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options))
 144 }
 145
 146 func PtraceGetEventMsg(pid int) (msg uint, err error) {
 147         var data _C_long
 148         err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data)))
 149         msg = uint(data)
 150         return
 151 }
 152
 153 func PtraceCont(pid int, signal int) (err error) {
 154         return ptrace(PTRACE_CONT, pid, 0, uintptr(signal))
 155 }
 156
 157 func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) }
 158
 159 func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) }
 160
 161 func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) }
 162
 163 //sys   reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error)
 164 //reboot(magic1 _C_uint, magic2 _C_uint, cmd _C_int, arg *byte) _C_int
 165 func Reboot(cmd int) (err error) {
 166         return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
 167 }
 168
 169 //sys   accept4(fd int, sa *RawSockaddrAny, len *Socklen_t, flags int) (nfd int, err error)
 170 //accept4(fd _C_int, sa *RawSockaddrAny, len *Socklen_t, flags _C_int) _C_int
 171
 172 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
 173         var rsa RawSockaddrAny
 174         var len Socklen_t = SizeofSockaddrAny
 175         nfd, err = accept4(fd, &rsa, &len, flags)
 176         if err != nil {
 177                 return -1, nil, err
 178         }
 179         sa, err = anyToSockaddr(&rsa)
 180         if err != nil {
 181                 Close(nfd)
 182                 return -1, nil, err
 183         }
 184         return nfd, sa, nil
 185 }
 186
 187 //sys   Acct(path string) (err error)
 188 //acct(path *byte) _C_int
 189
 190 //sys   Adjtimex(buf *Timex) (state int, err error)
 191 //adjtimex(buf *Timex) _C_int
 192
 193 //sysnb Dup3(oldfd int, newfd int, flags int) (err error)
 194 //dup3(oldfd _C_int, newfd _C_int, flags _C_int) _C_int
 195
 196 //sys   Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 197 //faccessat(dirfd _C_int, pathname *byte, mode _C_int, flags _C_int) _C_int
 198
 199 //sys   Fallocate(fd int, mode uint32, off int64, len int64) (err error)
 200 //fallocate(fd _C_int, mode _C_int, offset Offset_t, len Offset_t) _C_int
 201
 202 //sys   Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
 203 //fchmodat(dirfd _C_int, pathname *byte, mode Mode_t, flags _C_int) _C_int
 204
 205 //sys   Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
 206 //fchownat(dirfd _C_int, path *byte, owner Uid_t, group Gid_t, flags _C_int) _C_int
 207
 208 //sys   Flock(fd int, how int) (err error)
 209 //flock(fd _C_int, how _C_int) _C_int
 210
 211 //sys   Fstatfs(fd int, buf *Statfs_t) (err error)
 212 //fstatfs(fd _C_int, buf *Statfs_t) _C_int
 213
 214 func Gettid() (tid int) {
 215         r1, _, _ := Syscall(SYS_GETTID, 0, 0, 0)
 216         return int(r1)
 217 }
 218
 219 func Getdents(fd int, buf []byte) (n int, err error) {
 220         var p *byte
 221         if len(buf) > 0 {
 222                 p = &buf[0]
 223         } else {
 224                 p = (*byte)(unsafe.Pointer(&_zero))
 225         }
 226         Entersyscall()
 227         s := SYS_GETDENTS64
 228         if s == 0 {
 229                 s = SYS_GETDENTS
 230         }
 231         r1, _, errno := Syscall(uintptr(s), uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(len(buf)))
 232         n = int(r1)
 233         if n < 0 {
 234                 err = errno
 235         }
 236         Exitsyscall()
 237         return
 238 }
 239
 240 func clen(n []byte) int {
 241         for i := 0; i < len(n); i++ {
 242                 if n[i] == 0 {
 243                         return i
 244                 }
 245         }
 246         return len(n)
 247 }
 248
 249 func ReadDirent(fd int, buf []byte) (n int, err error) {
 250         return Getdents(fd, buf)
 251 }
 252
 253 func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
 254         origlen := len(buf)
 255         count = 0
 256         for max != 0 && len(buf) > 0 {
 257                 dirent := (*Dirent)(unsafe.Pointer(&buf[0]))
 258                 buf = buf[dirent.Reclen:]
 259                 if dirent.Ino == 0 { // File absent in directory.
 260                         continue
 261                 }
 262                 bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0]))
 263                 var name = string(bytes[0:clen(bytes[:])])
 264                 if name == "." || name == ".." { // Useless names
 265                         continue
 266                 }
 267                 max--
 268                 count++
 269                 names = append(names, name)
 270         }
 271         return origlen - len(buf), count, names
 272 }
 273
 274 //sys   Getxattr(path string, attr string, dest []byte) (sz int, err error)
 275 //getxattr(path *byte, attr *byte, buf *byte, count Size_t) Ssize_t
 276
 277 //sys   InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error)
 278 //inotify_add_watch(fd _C_int, pathname *byte, mask uint32) _C_int
 279
 280 //sysnb InotifyInit() (fd int, err error)
 281 //inotify_init() _C_int
 282
 283 //sysnb InotifyInit1(flags int) (fd int, err error)
 284 //inotify_init1(flags _C_int) _C_int
 285
 286 //sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error)
 287 //inotify_rm_watch(fd _C_int, wd uint32) _C_int
 288
 289 //sys   Klogctl(typ int, buf []byte) (n int, err error)
 290 //klogctl(typ _C_int, bufp *byte, len _C_int) _C_int
 291
 292 //sys   Listxattr(path string, dest []byte) (sz int, err error)
 293 //listxattr(path *byte, list *byte, size Size_t) Ssize_t
 294
 295 //sys   Mkdirat(dirfd int, path string, mode uint32) (err error)
 296 //mkdirat(dirfd _C_int, path *byte, mode Mode_t) _C_int
 297
 298 //sys   Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
 299 //mknodat(dirfd _C_int, path *byte, mode Mode_t, dev _dev_t) _C_int
 300
 301 //sysnb pipe2(p *[2]_C_int, flags int) (err error)
 302 //pipe2(p *[2]_C_int, flags _C_int) _C_int
 303 func Pipe2(p []int, flags int) (err error) {
 304         if len(p) != 2 {
 305                 return EINVAL
 306         }
 307         var pp [2]_C_int
 308         err = pipe2(&pp, flags)
 309         p[0] = int(pp[0])
 310         p[1] = int(pp[1])
 311         return
 312 }
 313
 314 //sys   PivotRoot(newroot string, putold string) (err error)
 315 //pivot_root(newroot *byte, putold *byte) _C_int
 316
 317 //sys   Removexattr(path string, attr string) (err error)
 318 //removexattr(path *byte, name *byte) _C_int
 319
 320 //sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
 321 //renameat(olddirfd _C_int, oldpath *byte, newdirfd _C_int, newpath *byte) _C_int
 322
 323 //sys   sendfile(outfd int, infd int, offset *Offset_t, count int) (written int, err error)
 324 //sendfile64(outfd _C_int, infd _C_int, offset *Offset_t, count Size_t) Ssize_t
 325 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 326         if raceenabled {
 327                 raceReleaseMerge(unsafe.Pointer(&ioSync))
 328         }
 329         var soff Offset_t
 330         var psoff *Offset_t
 331         if offset != nil {
 332                 psoff = &soff
 333         }
 334         written, err = sendfile(outfd, infd, psoff, count)
 335         if offset != nil {
 336                 *offset = int64(soff)
 337         }
 338         return
 339 }
 340
 341 //sys   Setfsgid(gid int) (err error)
 342 //setfsgid(gid Gid_t) _C_int
 343
 344 //sys   Setfsuid(uid int) (err error)
 345 //setfsuid(uid Uid_t) _C_int
 346
 347 //sysnb Setresgid(rgid int, egid int, sgid int) (err error)
 348 //setresgid(rgid Gid_t, egid Gid_t, sgid Gid_t) _C_int
 349
 350 //sysnb Setresuid(ruid int, eguid int, suid int) (err error)
 351 //setresuid(ruid Uid_t, euid Uid_t, suid Uid_t) _C_int
 352
 353 //sys   Setxattr(path string, attr string, data []byte, flags int) (err error)
 354 //setxattr(path *byte, name *byte, value *byte, size Size_t, flags _C_int) _C_int
 355
 356 //sys   splice(rfd int, roff *_loff_t, wfd int, woff *_loff_t, len int, flags int) (n int64, err error)
 357 //splice(rfd _C_int, roff *_loff_t, wfd _C_int, woff *_loff_t, len Size_t, flags _C_uint) Ssize_t
 358 func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) {
 359         var lroff _loff_t
 360         var plroff *_loff_t
 361         if roff != nil {
 362                 lroff = _loff_t(*roff)
 363                 plroff = &lroff
 364         }
 365         var lwoff _loff_t
 366         var plwoff *_loff_t
 367         if woff != nil {
 368                 lwoff = _loff_t(*woff)
 369                 plwoff = &lwoff
 370         }
 371         n, err = splice(rfd, plroff, wfd, plwoff, len, flags)
 372         if roff != nil {
 373                 *roff = int64(lroff)
 374         }
 375         if woff != nil {
 376                 *woff = int64(lwoff)
 377         }
 378         return
 379 }
 380
 381 //sys   Statfs(path string, buf *Statfs_t) (err error)
 382 //statfs(path *byte, buf *Statfs_t) _C_int
 383
 384 //sys   SyncFileRange(fd int, off int64, n int64, flags int) (err error)
 385 //sync_file_range(fd _C_int, off Offset_t, n Offset_t, flags _C_uint) _C_int
 386
 387 //sysnb Sysinfo(info *Sysinfo_t) (err error)
 388 //sysinfo(info *Sysinfo_t) _C_int
 389
 390 //sys   Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
 391 //tee(rfd _C_int, wfd _C_int, len Size_t, flags _C_uint) Ssize_t
 392
 393 func Tgkill(tgid int, tid int, sig Signal) error {
 394         r1, _, errno := Syscall(SYS_TGKILL, uintptr(tgid), uintptr(tid), uintptr(sig))
 395         if r1 < 0 {
 396                 return errno
 397         }
 398         return nil
 399 }
 400
 401 //sys   unlinkat(dirfd int, path string, flags int) (err error)
 402 //unlinkat(dirfd _C_int, path *byte, flags _C_int) _C_int
 403
 404 func Unlinkat(dirfd int, path string) (err error) {
 405         return unlinkat(dirfd, path, 0)
 406 }
 407
 408 //sys   Unmount(target string, flags int) (err error) = SYS_UMOUNT2
 409 //umount2(target *byte, flags _C_int) _C_int
 410
 411 //sys   Unshare(flags int) (err error)
 412 //unshare(flags _C_int) _C_int
 413
 414 //sys   Ustat(dev int, ubuf *Ustat_t) (err error)
 415 //ustat(dev _dev_t, ubuf *Ustat_t) _C_int