vendor/golang.org/x/sys/unix/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 // +build s390x,linux
   6
   7 package unix
   8
   9 import (
  10         "unsafe"
  11 )
  12
  13 //sys   Dup2(oldfd int, newfd int) (err error)
  14 //sys   EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
  15 //sys   Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64
  16 //sys   Fchown(fd int, uid int, gid int) (err error)
  17 //sys   Fstat(fd int, stat *Stat_t) (err error)
  18 //sys   Fstatfs(fd int, buf *Statfs_t) (err error)
  19 //sys   Ftruncate(fd int, length int64) (err error)
  20 //sysnb Getegid() (egid int)
  21 //sysnb Geteuid() (euid int)
  22 //sysnb Getgid() (gid int)
  23 //sysnb Getrlimit(resource int, rlim *Rlimit) (err error)
  24 //sysnb Getuid() (uid int)
  25 //sysnb InotifyInit() (fd int, err error)
  26 //sys   Lchown(path string, uid int, gid int) (err error)
  27 //sys   Lstat(path string, stat *Stat_t) (err error)
  28 //sys   Pause() (err error)
  29 //sys   Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
  30 //sys   Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
  31 //sys   Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK
  32 //sys   Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
  33 //sys   sendfile(outfd int, infd int, offset *int64, count int) (written int, err error)
  34 //sys   Setfsgid(gid int) (err error)
  35 //sys   Setfsuid(uid int) (err error)
  36 //sysnb Setregid(rgid int, egid int) (err error)
  37 //sysnb Setresgid(rgid int, egid int, sgid int) (err error)
  38 //sysnb Setresuid(ruid int, euid int, suid int) (err error)
  39 //sysnb Setrlimit(resource int, rlim *Rlimit) (err error)
  40 //sysnb Setreuid(ruid int, euid int) (err error)
  41 //sys   Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)
  42 //sys   Stat(path string, stat *Stat_t) (err error)
  43 //sys   Statfs(path string, buf *Statfs_t) (err error)
  44 //sys   SyncFileRange(fd int, off int64, n int64, flags int) (err error)
  45 //sys   Truncate(path string, length int64) (err error)
  46 //sysnb getgroups(n int, list *_Gid_t) (nn int, err error)
  47 //sysnb setgroups(n int, list *_Gid_t) (err error)
  48
  49 func Getpagesize() int { return 4096 }
  50
  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
  67 func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
  68
  69 func NsecToTimespec(nsec int64) (ts Timespec) {
  70         ts.Sec = nsec / 1e9
  71         ts.Nsec = nsec % 1e9
  72         return
  73 }
  74
  75 func NsecToTimeval(nsec int64) (tv Timeval) {
  76         nsec += 999 // round up to microsecond
  77         tv.Sec = nsec / 1e9
  78         tv.Usec = nsec % 1e9 / 1e3
  79         return
  80 }
  81
  82 //sysnb pipe2(p *[2]_C_int, flags int) (err error)
  83
  84 func Pipe(p []int) (err error) {
  85         if len(p) != 2 {
  86                 return EINVAL
  87         }
  88         var pp [2]_C_int
  89         err = pipe2(&pp, 0) // pipe2 is the same as pipe when flags are set to 0.
  90         p[0] = int(pp[0])
  91         p[1] = int(pp[1])
  92         return
  93 }
  94
  95 func Pipe2(p []int, flags int) (err error) {
  96         if len(p) != 2 {
  97                 return EINVAL
  98         }
  99         var pp [2]_C_int
 100         err = pipe2(&pp, flags)
 101         p[0] = int(pp[0])
 102         p[1] = int(pp[1])
 103         return
 104 }
 105
 106 func Ioperm(from int, num int, on int) (err error) {
 107         return ENOSYS
 108 }
 109
 110 func Iopl(level int) (err error) {
 111         return ENOSYS
 112 }
 113
 114 func (r *PtraceRegs) PC() uint64 { return r.Psw.Addr }
 115
 116 func (r *PtraceRegs) SetPC(pc uint64) { r.Psw.Addr = pc }
 117
 118 func (iov *Iovec) SetLen(length int) {
 119         iov.Len = uint64(length)
 120 }
 121
 122 func (msghdr *Msghdr) SetControllen(length int) {
 123         msghdr.Controllen = uint64(length)
 124 }
 125
 126 func (cmsg *Cmsghdr) SetLen(length int) {
 127         cmsg.Len = uint64(length)
 128 }
 129
 130 // Linux on s390x uses the old mmap interface, which requires arguments to be passed in a struct.
 131 // mmap2 also requires arguments to be passed in a struct; it is currently not exposed in <asm/unistd.h>.
 132 func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
 133         mmap_args := [6]uintptr{addr, length, uintptr(prot), uintptr(flags), uintptr(fd), uintptr(offset)}
 134         r0, _, e1 := Syscall(SYS_MMAP, uintptr(unsafe.Pointer(&mmap_args[0])), 0, 0)
 135         xaddr = uintptr(r0)
 136         if e1 != 0 {
 137                 err = errnoErr(e1)
 138         }
 139         return
 140 }
 141
 142 // On s390x Linux, all the socket calls go through an extra indirection.
 143 // The arguments to the underlying system call (SYS_SOCKETCALL) are the
 144 // number below and a pointer to an array of uintptr.
 145 const (
 146         // see linux/net.h
 147         netSocket      = 1
 148         netBind        = 2
 149         netConnect     = 3
 150         netListen      = 4
 151         netAccept      = 5
 152         netGetSockName = 6
 153         netGetPeerName = 7
 154         netSocketPair  = 8
 155         netSend        = 9
 156         netRecv        = 10
 157         netSendTo      = 11
 158         netRecvFrom    = 12
 159         netShutdown    = 13
 160         netSetSockOpt  = 14
 161         netGetSockOpt  = 15
 162         netSendMsg     = 16
 163         netRecvMsg     = 17
 164         netAccept4     = 18
 165         netRecvMMsg    = 19
 166         netSendMMsg    = 20
 167 )
 168
 169 func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (int, error) {
 170         args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))}
 171         fd, _, err := Syscall(SYS_SOCKETCALL, netAccept, uintptr(unsafe.Pointer(&args)), 0)
 172         if err != 0 {
 173                 return 0, err
 174         }
 175         return int(fd), nil
 176 }
 177
 178 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (int, error) {
 179         args := [4]uintptr{uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags)}
 180         fd, _, err := Syscall(SYS_SOCKETCALL, netAccept4, uintptr(unsafe.Pointer(&args)), 0)
 181         if err != 0 {
 182                 return 0, err
 183         }
 184         return int(fd), nil
 185 }
 186
 187 func getsockname(s int, rsa *RawSockaddrAny, addrlen *_Socklen) error {
 188         args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))}
 189         _, _, err := RawSyscall(SYS_SOCKETCALL, netGetSockName, uintptr(unsafe.Pointer(&args)), 0)
 190         if err != 0 {
 191                 return err
 192         }
 193         return nil
 194 }
 195
 196 func getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) error {
 197         args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))}
 198         _, _, err := RawSyscall(SYS_SOCKETCALL, netGetPeerName, uintptr(unsafe.Pointer(&args)), 0)
 199         if err != 0 {
 200                 return err
 201         }
 202         return nil
 203 }
 204
 205 func socketpair(domain int, typ int, flags int, fd *[2]int32) error {
 206         args := [4]uintptr{uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd))}
 207         _, _, err := RawSyscall(SYS_SOCKETCALL, netSocketPair, uintptr(unsafe.Pointer(&args)), 0)
 208         if err != 0 {
 209                 return err
 210         }
 211         return nil
 212 }
 213
 214 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) error {
 215         args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)}
 216         _, _, err := Syscall(SYS_SOCKETCALL, netBind, uintptr(unsafe.Pointer(&args)), 0)
 217         if err != 0 {
 218                 return err
 219         }
 220         return nil
 221 }
 222
 223 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) error {
 224         args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)}
 225         _, _, err := Syscall(SYS_SOCKETCALL, netConnect, uintptr(unsafe.Pointer(&args)), 0)
 226         if err != 0 {
 227                 return err
 228         }
 229         return nil
 230 }
 231
 232 func socket(domain int, typ int, proto int) (int, error) {
 233         args := [3]uintptr{uintptr(domain), uintptr(typ), uintptr(proto)}
 234         fd, _, err := RawSyscall(SYS_SOCKETCALL, netSocket, uintptr(unsafe.Pointer(&args)), 0)
 235         if err != 0 {
 236                 return 0, err
 237         }
 238         return int(fd), nil
 239 }
 240
 241 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) error {
 242         args := [5]uintptr{uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen))}
 243         _, _, err := Syscall(SYS_SOCKETCALL, netGetSockOpt, uintptr(unsafe.Pointer(&args)), 0)
 244         if err != 0 {
 245                 return err
 246         }
 247         return nil
 248 }
 249
 250 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) error {
 251         args := [4]uintptr{uintptr(s), uintptr(level), uintptr(name), uintptr(val)}
 252         _, _, err := Syscall(SYS_SOCKETCALL, netSetSockOpt, uintptr(unsafe.Pointer(&args)), 0)
 253         if err != 0 {
 254                 return err
 255         }
 256         return nil
 257 }
 258
 259 func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (int, error) {
 260         var base uintptr
 261         if len(p) > 0 {
 262                 base = uintptr(unsafe.Pointer(&p[0]))
 263         }
 264         args := [6]uintptr{uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))}
 265         n, _, err := Syscall(SYS_SOCKETCALL, netRecvFrom, uintptr(unsafe.Pointer(&args)), 0)
 266         if err != 0 {
 267                 return 0, err
 268         }
 269         return int(n), nil
 270 }
 271
 272 func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) error {
 273         var base uintptr
 274         if len(p) > 0 {
 275                 base = uintptr(unsafe.Pointer(&p[0]))
 276         }
 277         args := [6]uintptr{uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen)}
 278         _, _, err := Syscall(SYS_SOCKETCALL, netSendTo, uintptr(unsafe.Pointer(&args)), 0)
 279         if err != 0 {
 280                 return err
 281         }
 282         return nil
 283 }
 284
 285 func recvmsg(s int, msg *Msghdr, flags int) (int, error) {
 286         args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)}
 287         n, _, err := Syscall(SYS_SOCKETCALL, netRecvMsg, uintptr(unsafe.Pointer(&args)), 0)
 288         if err != 0 {
 289                 return 0, err
 290         }
 291         return int(n), nil
 292 }
 293
 294 func sendmsg(s int, msg *Msghdr, flags int) (int, error) {
 295         args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)}
 296         n, _, err := Syscall(SYS_SOCKETCALL, netSendMsg, uintptr(unsafe.Pointer(&args)), 0)
 297         if err != 0 {
 298                 return 0, err
 299         }
 300         return int(n), nil
 301 }
 302
 303 func Listen(s int, n int) error {
 304         args := [2]uintptr{uintptr(s), uintptr(n)}
 305         _, _, err := Syscall(SYS_SOCKETCALL, netListen, uintptr(unsafe.Pointer(&args)), 0)
 306         if err != 0 {
 307                 return err
 308         }
 309         return nil
 310 }
 311
 312 func Shutdown(s, how int) error {
 313         args := [2]uintptr{uintptr(s), uintptr(how)}
 314         _, _, err := Syscall(SYS_SOCKETCALL, netShutdown, uintptr(unsafe.Pointer(&args)), 0)
 315         if err != 0 {
 316                 return err
 317         }
 318         return nil
 319 }
 320
 321 //sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
 322
 323 func Poll(fds []PollFd, timeout int) (n int, err error) {
 324         if len(fds) == 0 {
 325                 return poll(nil, 0, timeout)
 326         }
 327         return poll(&fds[0], len(fds), timeout)
 328 }