src/syscall/syscall_linux_s390x.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 package syscall
   6
   7 import "unsafe"
   8
   9 const (
  10         _SYS_setgroups         = SYS_SETGROUPS
  11         _SYS_clone3            = 435
  12         _SYS_faccessat2        = 439
  13         _SYS_pidfd_send_signal = 424
  14         _SYS_fchmodat2         = 452
  15 )
  16
  17 //sys   Dup2(oldfd int, newfd int) (err error)
  18 //sys   EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
  19 //sys   Fchown(fd int, uid int, gid int) (err error)
  20 //sys   Fstat(fd int, stat *Stat_t) (err error)
  21 //sys   fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_NEWFSTATAT
  22 //sys   Fstatfs(fd int, buf *Statfs_t) (err error)
  23 //sys   Ftruncate(fd int, length int64) (err error)
  24 //sysnb Getegid() (egid int)
  25 //sysnb Geteuid() (euid int)
  26 //sysnb Getgid() (gid int)
  27 //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_GETRLIMIT
  28 //sysnb Getuid() (uid int)
  29 //sysnb InotifyInit() (fd int, err error)
  30 //sys   Lchown(path string, uid int, gid int) (err error)
  31 //sys   Lstat(path string, stat *Stat_t) (err error)
  32 //sys   Pause() (err error)
  33 //sys   pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
  34 //sys   pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
  35 //sys   Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
  36 //sys   Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK
  37 //sys   Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
  38 //sys   sendfile(outfd int, infd int, offset *int64, count int) (written int, err error)
  39 //sys   Setfsgid(gid int) (err error)
  40 //sys   Setfsuid(uid int) (err error)
  41 //sysnb setrlimit(resource int, rlim *Rlimit) (err error) = SYS_SETRLIMIT
  42 //sys   Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)
  43 //sys   Stat(path string, stat *Stat_t) (err error)
  44 //sys   Statfs(path string, buf *Statfs_t) (err error)
  45 //sys   SyncFileRange(fd int, off int64, n int64, flags int) (err error) = SYS_SYNC_FILE_RANGE
  46 //sys   Truncate(path string, length int64) (err error)
  47 //sys   Ustat(dev int, ubuf *Ustat_t) (err error)
  48 //sysnb getgroups(n int, list *_Gid_t) (nn int, err error)
  49
  50 //sys   futimesat(dirfd int, path string, times *[2]Timeval) (err error)
  51 //sysnb Gettimeofday(tv *Timeval) (err error)
  52
  53 func Time(t *Time_t) (tt Time_t, err error) {
  54         var tv Timeval
  55         err = Gettimeofday(&tv)
  56         if err != nil {
  57                 return 0, err
  58         }
  59         if t != nil {
  60                 *t = Time_t(tv.Sec)
  61         }
  62         return Time_t(tv.Sec), nil
  63 }
  64
  65 //sys   Utime(path string, buf *Utimbuf) (err error)
  66 //sys   utimes(path string, times *[2]Timeval) (err error)
  67
  68 func setTimespec(sec, nsec int64) Timespec {
  69         return Timespec{Sec: sec, Nsec: nsec}
  70 }
  71
  72 func setTimeval(sec, usec int64) Timeval {
  73         return Timeval{Sec: sec, Usec: usec}
  74 }
  75
  76 // Linux on s390x uses the old mmap interface, which requires arguments to be passed in a struct.
  77 // mmap2 also requires arguments to be passed in a struct; it is currently not exposed in <asm/unistd.h>.
  78 func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
  79         mmap_args := [6]uintptr{addr, length, uintptr(prot), uintptr(flags), uintptr(fd), uintptr(offset)}
  80         r0, _, e1 := Syscall(SYS_MMAP, uintptr(unsafe.Pointer(&mmap_args[0])), 0, 0)
  81         xaddr = uintptr(r0)
  82         if e1 != 0 {
  83                 err = errnoErr(e1)
  84         }
  85         return
  86 }
  87
  88 // On s390x Linux, all the socket calls go through an extra indirection.
  89 // The arguments to the underlying system call are the number below
  90 // and a pointer to an array of uintptr.  We hide the pointer in the
  91 // socketcall assembly to avoid allocation on every system call.
  92
  93 const (
  94         // see linux/net.h
  95         _SOCKET      = 1
  96         _BIND        = 2
  97         _CONNECT     = 3
  98         _LISTEN      = 4
  99         _ACCEPT      = 5
 100         _GETSOCKNAME = 6
 101         _GETPEERNAME = 7
 102         _SOCKETPAIR  = 8
 103         _SEND        = 9
 104         _RECV        = 10
 105         _SENDTO      = 11
 106         _RECVFROM    = 12
 107         _SHUTDOWN    = 13
 108         _SETSOCKOPT  = 14
 109         _GETSOCKOPT  = 15
 110         _SENDMSG     = 16
 111         _RECVMSG     = 17
 112         _ACCEPT4     = 18
 113         _RECVMMSG    = 19
 114         _SENDMMSG    = 20
 115 )
 116
 117 func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
 118 func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
 119
 120 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
 121         fd, e := socketcall(_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
 122         if e != 0 {
 123                 err = e
 124         }
 125         return
 126 }
 127
 128 func getsockname(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 129         _, e := rawsocketcall(_GETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 130         if e != 0 {
 131                 err = e
 132         }
 133         return
 134 }
 135
 136 func getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
 137         _, e := rawsocketcall(_GETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
 138         if e != 0 {
 139                 err = e
 140         }
 141         return
 142 }
 143
 144 func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
 145         _, e := rawsocketcall(_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
 146         if e != 0 {
 147                 err = e
 148         }
 149         return
 150 }
 151
 152 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 153         _, e := socketcall(_BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
 154         if e != 0 {
 155                 err = e
 156         }
 157         return
 158 }
 159
 160 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
 161         _, e := socketcall(_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
 162         if e != 0 {
 163                 err = e
 164         }
 165         return
 166 }
 167
 168 func socket(domain int, typ int, proto int) (fd int, err error) {
 169         fd, e := rawsocketcall(_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0)
 170         if e != 0 {
 171                 err = e
 172         }
 173         return
 174 }
 175
 176 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
 177         _, e := socketcall(_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 178         if e != 0 {
 179                 err = e
 180         }
 181         return
 182 }
 183
 184 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
 185         _, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0)
 186         if e != 0 {
 187                 err = e
 188         }
 189         return
 190 }
 191
 192 func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
 193         var base uintptr
 194         if len(p) > 0 {
 195                 base = uintptr(unsafe.Pointer(&p[0]))
 196         }
 197         n, e := socketcall(_RECVFROM, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 198         if e != 0 {
 199                 err = e
 200         }
 201         return
 202 }
 203
 204 func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
 205         var base uintptr
 206         if len(p) > 0 {
 207                 base = uintptr(unsafe.Pointer(&p[0]))
 208         }
 209         _, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen))
 210         if e != 0 {
 211                 err = e
 212         }
 213         return
 214 }
 215
 216 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 217         n, e := socketcall(_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
 218         if e != 0 {
 219                 err = e
 220         }
 221         return
 222 }
 223
 224 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
 225         n, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
 226         if e != 0 {
 227                 err = e
 228         }
 229         return
 230 }
 231
 232 func Listen(s int, n int) (err error) {
 233         _, e := socketcall(_LISTEN, uintptr(s), uintptr(n), 0, 0, 0, 0)
 234         if e != 0 {
 235                 err = e
 236         }
 237         return
 238 }
 239
 240 func Shutdown(s, how int) (err error) {
 241         _, e := socketcall(_SHUTDOWN, uintptr(s), uintptr(how), 0, 0, 0, 0)
 242         if e != 0 {
 243                 err = e
 244         }
 245         return
 246 }
 247
 248 //go:nosplit
 249 func rawSetrlimit(resource int, rlim *Rlimit) Errno {
 250         _, _, errno := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
 251         return errno
 252 }
 253
 254 func (r *PtraceRegs) PC() uint64 { return r.Psw.Addr }
 255
 256 func (r *PtraceRegs) SetPC(pc uint64) { r.Psw.Addr = pc }
 257
 258 func (iov *Iovec) SetLen(length int) {
 259         iov.Len = uint64(length)
 260 }
 261
 262 func (msghdr *Msghdr) SetControllen(length int) {
 263         msghdr.Controllen = uint64(length)
 264 }
 265
 266 func (cmsg *Cmsghdr) SetLen(length int) {
 267         cmsg.Len = uint64(length)
 268 }