src/syscall/syscall_linux_mipsx.go

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