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