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  }
   267
View as plain text