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