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