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