github.com/c12o16h1/go/src@v0.0.0-20200114212001-5a151c0f00ed/syscall/syscall_linux_s390x.go (about)

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