src/syscall/syscall_linux_arm.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 package syscall
   6
   7 import "unsafe"
   8
   9 const (
  10         _SYS_setgroups         = SYS_SETGROUPS32
  11         _SYS_clone3            = 435
  12         _SYS_faccessat2        = 439
  13         _SYS_pidfd_send_signal = 424
  14         _SYS_fchmodat2         = 452
  15 )
  16
  17 func setTimespec(sec, nsec int64) Timespec {
  18         return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
  19 }
  20
  21 func setTimeval(sec, usec int64) Timeval {
  22         return Timeval{Sec: int32(sec), Usec: int32(usec)}
  23 }
  24
  25 // Underlying system call writes to newoffset via pointer.
  26 // Implemented in assembly to avoid allocation.
  27 func seek(fd int, offset int64, whence int) (newoffset int64, err Errno)
  28
  29 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
  30         newoffset, errno := seek(fd, offset, whence)
  31         if errno != 0 {
  32                 return 0, errno
  33         }
  34         return newoffset, nil
  35 }
  36
  37 //sys   accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error)
  38 //sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
  39 //sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
  40 //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) = SYS_GETGROUPS32
  41 //sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
  42 //sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
  43 //sysnb socket(domain int, typ int, proto int) (fd int, err error)
  44 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
  45 //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
  46 //sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
  47 //sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
  48 //sysnb socketpair(domain int, typ int, flags int, fd *[2]int32) (err error)
  49 //sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
  50 //sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error)
  51
  52 // 64-bit file system and 32-bit uid calls
  53 // (16-bit uid calls are not always supported in newer kernels)
  54 //sys   Dup2(oldfd int, newfd int) (err error)
  55 //sys   Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32
  56 //sys   Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
  57 //sys   fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
  58 //sysnb Getegid() (egid int) = SYS_GETEGID32
  59 //sysnb Geteuid() (euid int) = SYS_GETEUID32
  60 //sysnb Getgid() (gid int) = SYS_GETGID32
  61 //sysnb Getuid() (uid int) = SYS_GETUID32
  62 //sysnb InotifyInit() (fd int, err error)
  63 //sys   Listen(s int, n int) (err error)
  64 //sys   Pause() (err error)
  65 //sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
  66 //sys   sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = SYS_SENDFILE64
  67 //sys   Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) = SYS__NEWSELECT
  68 //sys   Setfsgid(gid int) (err error) = SYS_SETFSGID32
  69 //sys   Setfsuid(uid int) (err error) = SYS_SETFSUID32
  70 //sys   Shutdown(fd int, how int) (err error)
  71 //sys   Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
  72 //sys   Ustat(dev int, ubuf *Ustat_t) (err error)
  73
  74 //sys   futimesat(dirfd int, path string, times *[2]Timeval) (err error)
  75 //sysnb Gettimeofday(tv *Timeval) (err error)
  76 //sysnb Time(t *Time_t) (tt Time_t, err error)
  77 //sys   Utime(path string, buf *Utimbuf) (err error)
  78 //sys   utimes(path string, times *[2]Timeval) (err error)
  79
  80 //sys   pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
  81 //sys   pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
  82 //sys   Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
  83 //sys   Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
  84
  85 //sys   mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error)
  86 //sys   EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
  87
  88 func Stat(path string, stat *Stat_t) (err error) {
  89         return fstatat(_AT_FDCWD, path, stat, 0)
  90 }
  91
  92 func Lchown(path string, uid int, gid int) (err error) {
  93         return Fchownat(_AT_FDCWD, path, uid, gid, _AT_SYMLINK_NOFOLLOW)
  94 }
  95
  96 func Lstat(path string, stat *Stat_t) (err error) {
  97         return fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW)
  98 }
  99
 100 func Fstatfs(fd int, buf *Statfs_t) (err error) {
 101         _, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
 102         if e != 0 {
 103                 err = e
 104         }
 105         return
 106 }
 107
 108 func Statfs(path string, buf *Statfs_t) (err error) {
 109         pathp, err := BytePtrFromString(path)
 110         if err != nil {
 111                 return err
 112         }
 113         _, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
 114         if e != 0 {
 115                 err = e
 116         }
 117         return
 118 }
 119
 120 func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
 121         page := uintptr(offset / 4096)
 122         if offset != int64(page)*4096 {
 123                 return 0, EINVAL
 124         }
 125         return mmap2(addr, length, prot, flags, fd, page)
 126 }
 127
 128 type rlimit32 struct {
 129         Cur uint32
 130         Max uint32
 131 }
 132
 133 //sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 134
 135 const rlimInf32 = ^uint32(0)
 136 const rlimInf64 = ^uint64(0)
 137
 138 func Getrlimit(resource int, rlim *Rlimit) (err error) {
 139         err = prlimit(0, resource, nil, rlim)
 140         if err != ENOSYS {
 141                 return err
 142         }
 143
 144         rl := rlimit32{}
 145         err = getrlimit(resource, &rl)
 146         if err != nil {
 147                 return
 148         }
 149
 150         if rl.Cur == rlimInf32 {
 151                 rlim.Cur = rlimInf64
 152         } else {
 153                 rlim.Cur = uint64(rl.Cur)
 154         }
 155
 156         if rl.Max == rlimInf32 {
 157                 rlim.Max = rlimInf64
 158         } else {
 159                 rlim.Max = uint64(rl.Max)
 160         }
 161         return
 162 }
 163
 164 //sysnb setrlimit1(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 165
 166 func setrlimit(resource int, rlim *Rlimit) (err error) {
 167         err = prlimit(0, resource, rlim, nil)
 168         if err != ENOSYS {
 169                 return err
 170         }
 171
 172         rl := rlimit32{}
 173         if rlim.Cur == rlimInf64 {
 174                 rl.Cur = rlimInf32
 175         } else if rlim.Cur < uint64(rlimInf32) {
 176                 rl.Cur = uint32(rlim.Cur)
 177         } else {
 178                 return EINVAL
 179         }
 180         if rlim.Max == rlimInf64 {
 181                 rl.Max = rlimInf32
 182         } else if rlim.Max < uint64(rlimInf32) {
 183                 rl.Max = uint32(rlim.Max)
 184         } else {
 185                 return EINVAL
 186         }
 187
 188         return setrlimit1(resource, &rl)
 189 }
 190
 191 //go:nosplit
 192 func rawSetrlimit(resource int, rlim *Rlimit) Errno {
 193         _, _, errno := RawSyscall6(SYS_PRLIMIT64, 0, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0, 0, 0)
 194         if errno != ENOSYS {
 195                 return errno
 196         }
 197
 198         rl := rlimit32{}
 199         if rlim.Cur == rlimInf64 {
 200                 rl.Cur = rlimInf32
 201         } else if rlim.Cur < uint64(rlimInf32) {
 202                 rl.Cur = uint32(rlim.Cur)
 203         } else {
 204                 return EINVAL
 205         }
 206         if rlim.Max == rlimInf64 {
 207                 rl.Max = rlimInf32
 208         } else if rlim.Max < uint64(rlimInf32) {
 209                 rl.Max = uint32(rlim.Max)
 210         } else {
 211                 return EINVAL
 212         }
 213
 214         _, _, errno = RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 215         return errno
 216 }
 217
 218 func (r *PtraceRegs) PC() uint64 { return uint64(r.Uregs[15]) }
 219
 220 func (r *PtraceRegs) SetPC(pc uint64) { r.Uregs[15] = uint32(pc) }
 221
 222 func (iov *Iovec) SetLen(length int) {
 223         iov.Len = uint32(length)
 224 }
 225
 226 func (msghdr *Msghdr) SetControllen(length int) {
 227         msghdr.Controllen = uint32(length)
 228 }
 229
 230 func (cmsg *Cmsghdr) SetLen(length int) {
 231         cmsg.Len = uint32(length)
 232 }