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