Source file src/syscall/syscall_aix.go

     1  // Copyright 2018 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  // Aix system calls.
     6  // This file is compiled as ordinary Go code,
     7  // but it is also input to mksyscall,
     8  // which parses the //sys lines and generates system call stubs.
     9  // Note that sometimes we use a lowercase //sys name and
    10  // wrap it in our own nicer implementation.
    11  
    12  package syscall
    13  
    14  import (
    15  	"unsafe"
    16  )
    17  
    18  func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
    19  func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
    20  func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
    21  func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
    22  
    23  // Implemented in runtime/syscall_aix.go.
    24  // Accessed in assembly in x/sys/unix and x/sys/cpu.
    25  //
    26  //go:linkname rawSyscall6
    27  func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
    28  
    29  //go:linkname syscall6
    30  func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
    31  
    32  // Constant expected by package but not supported
    33  const (
    34  	_ = iota
    35  	TIOCSCTTY
    36  	SYS_EXECVE
    37  	SYS_FCNTL
    38  )
    39  
    40  const (
    41  	F_DUPFD_CLOEXEC = 0
    42  	// AF_LOCAL doesn't exist on AIX
    43  	AF_LOCAL = AF_UNIX
    44  
    45  	_F_DUP2FD_CLOEXEC = 0
    46  )
    47  
    48  func (ts *StTimespec_t) Unix() (sec int64, nsec int64) {
    49  	return int64(ts.Sec), int64(ts.Nsec)
    50  }
    51  
    52  func (ts *StTimespec_t) Nano() int64 {
    53  	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
    54  }
    55  
    56  /*
    57   * Wrapped
    58   */
    59  
    60  func Access(path string, mode uint32) (err error) {
    61  	return Faccessat(_AT_FDCWD, path, mode, 0)
    62  }
    63  
    64  // fcntl must never be called with cmd=F_DUP2FD because it doesn't work on AIX
    65  // There is no way to create a custom fcntl and to keep //sys fcntl easily,
    66  // because we need fcntl name for its libc symbol. This is linked with the script.
    67  // But, as fcntl is currently not exported and isn't called with F_DUP2FD,
    68  // it doesn't matter.
    69  //sys	fcntl(fd int, cmd int, arg int) (val int, err error)
    70  //sys	Dup2(old int, new int) (err error)
    71  
    72  //sysnb pipe(p *[2]_C_int) (err error)
    73  
    74  func Pipe(p []int) (err error) {
    75  	if len(p) != 2 {
    76  		return EINVAL
    77  	}
    78  	var pp [2]_C_int
    79  	err = pipe(&pp)
    80  	if err == nil {
    81  		p[0] = int(pp[0])
    82  		p[1] = int(pp[1])
    83  	}
    84  	return
    85  }
    86  
    87  //sys	readlink(path string, buf []byte, bufSize uint64) (n int, err error)
    88  
    89  func Readlink(path string, buf []byte) (n int, err error) {
    90  	s := uint64(len(buf))
    91  	return readlink(path, buf, s)
    92  }
    93  
    94  //sys	utimes(path string, times *[2]Timeval) (err error)
    95  
    96  func Utimes(path string, tv []Timeval) error {
    97  	if len(tv) != 2 {
    98  		return EINVAL
    99  	}
   100  	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
   101  }
   102  
   103  //sys	utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
   104  
   105  func UtimesNano(path string, ts []Timespec) error {
   106  	if len(ts) != 2 {
   107  		return EINVAL
   108  	}
   109  	return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
   110  }
   111  
   112  //sys	unlinkat(dirfd int, path string, flags int) (err error)
   113  
   114  func Unlinkat(dirfd int, path string) (err error) {
   115  	return unlinkat(dirfd, path, 0)
   116  }
   117  
   118  //sys	getcwd(buf *byte, size uint64) (err error)
   119  
   120  const ImplementsGetwd = true
   121  
   122  func Getwd() (ret string, err error) {
   123  	for len := uint64(4096); ; len *= 2 {
   124  		b := make([]byte, len)
   125  		err := getcwd(&b[0], len)
   126  		if err == nil {
   127  			n := clen(b[:])
   128  			if n < 1 {
   129  				return "", EINVAL
   130  			}
   131  			return string(b[:n]), nil
   132  		}
   133  		if err != ERANGE {
   134  			return "", err
   135  		}
   136  	}
   137  }
   138  
   139  func Getcwd(buf []byte) (n int, err error) {
   140  	err = getcwd(&buf[0], uint64(len(buf)))
   141  	if err == nil {
   142  		i := 0
   143  		for buf[i] != 0 {
   144  			i++
   145  		}
   146  		n = i + 1
   147  	}
   148  	return
   149  }
   150  
   151  //sysnb	getgroups(ngid int, gid *_Gid_t) (n int, err error)
   152  //sysnb	setgroups(ngid int, gid *_Gid_t) (err error)
   153  
   154  func Getgroups() (gids []int, err error) {
   155  	n, err := getgroups(0, nil)
   156  	if err != nil {
   157  		return nil, err
   158  	}
   159  	if n == 0 {
   160  		return nil, nil
   161  	}
   162  
   163  	// Sanity check group count. Max is 16 on BSD.
   164  	if n < 0 || n > 1000 {
   165  		return nil, EINVAL
   166  	}
   167  
   168  	a := make([]_Gid_t, n)
   169  	n, err = getgroups(n, &a[0])
   170  	if err != nil {
   171  		return nil, err
   172  	}
   173  	gids = make([]int, n)
   174  	for i, v := range a[0:n] {
   175  		gids[i] = int(v)
   176  	}
   177  	return
   178  }
   179  
   180  func Setgroups(gids []int) (err error) {
   181  	if len(gids) == 0 {
   182  		return setgroups(0, nil)
   183  	}
   184  
   185  	a := make([]_Gid_t, len(gids))
   186  	for i, v := range gids {
   187  		a[i] = _Gid_t(v)
   188  	}
   189  	return setgroups(len(a), &a[0])
   190  }
   191  
   192  func direntIno(buf []byte) (uint64, bool) {
   193  	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
   194  }
   195  
   196  func direntReclen(buf []byte) (uint64, bool) {
   197  	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
   198  }
   199  
   200  func direntNamlen(buf []byte) (uint64, bool) {
   201  	reclen, ok := direntReclen(buf)
   202  	if !ok {
   203  		return 0, false
   204  	}
   205  	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
   206  }
   207  
   208  func Gettimeofday(tv *Timeval) (err error) {
   209  	err = gettimeofday(tv, nil)
   210  	return
   211  }
   212  
   213  // TODO
   214  func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
   215  	return -1, ENOSYS
   216  }
   217  
   218  //sys	getdirent(fd int, buf []byte) (n int, err error)
   219  
   220  func ReadDirent(fd int, buf []byte) (n int, err error) {
   221  	return getdirent(fd, buf)
   222  }
   223  
   224  //sys  wait4(pid _Pid_t, status *_C_int, options int, rusage *Rusage) (wpid _Pid_t, err error)
   225  
   226  func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
   227  	var status _C_int
   228  	var r _Pid_t
   229  	err = ERESTART
   230  	// AIX wait4 may return with ERESTART errno, while the process is still
   231  	// active.
   232  	for err == ERESTART {
   233  		r, err = wait4(_Pid_t(pid), &status, options, rusage)
   234  	}
   235  	wpid = int(r)
   236  	if wstatus != nil {
   237  		*wstatus = WaitStatus(status)
   238  	}
   239  	return
   240  }
   241  
   242  //sys	fsyncRange(fd int, how int, start int64, length int64) (err error) = fsync_range
   243  
   244  func Fsync(fd int) error {
   245  	return fsyncRange(fd, O_SYNC, 0, 0)
   246  }
   247  
   248  /*
   249   * Socket
   250   */
   251  //sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
   252  //sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
   253  //sys   Getkerninfo(op int32, where uintptr, size uintptr, arg int64) (i int32, err error)
   254  //sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
   255  //sys	Listen(s int, backlog int) (err error)
   256  //sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
   257  //sys	socket(domain int, typ int, proto int) (fd int, err error)
   258  //sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error)
   259  //sysnb	getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
   260  //sys	getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
   261  //sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
   262  //sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
   263  //sys	Shutdown(s int, how int) (err error)
   264  
   265  // In order to use msghdr structure with Control, Controllen in golang.org/x/net,
   266  // nrecvmsg and nsendmsg must be used.
   267  //sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = nrecvmsg
   268  //sys	sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = nsendmsg
   269  
   270  func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
   271  	if sa.Port < 0 || sa.Port > 0xFFFF {
   272  		return nil, 0, EINVAL
   273  	}
   274  	sa.raw.Family = AF_INET
   275  	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
   276  	p[0] = byte(sa.Port >> 8)
   277  	p[1] = byte(sa.Port)
   278  	sa.raw.Addr = sa.Addr
   279  	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
   280  }
   281  
   282  func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
   283  	if sa.Port < 0 || sa.Port > 0xFFFF {
   284  		return nil, 0, EINVAL
   285  	}
   286  	sa.raw.Family = AF_INET6
   287  	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
   288  	p[0] = byte(sa.Port >> 8)
   289  	p[1] = byte(sa.Port)
   290  	sa.raw.Scope_id = sa.ZoneId
   291  	sa.raw.Addr = sa.Addr
   292  	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
   293  }
   294  
   295  func (sa *RawSockaddrUnix) setLen(n int) {
   296  	sa.Len = uint8(3 + n) // 2 for Family, Len; 1 for NUL.
   297  }
   298  
   299  func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
   300  	name := sa.Name
   301  	n := len(name)
   302  	if n > len(sa.raw.Path) {
   303  		return nil, 0, EINVAL
   304  	}
   305  	sa.raw.Family = AF_UNIX
   306  	sa.raw.setLen(n)
   307  	for i := 0; i < n; i++ {
   308  		sa.raw.Path[i] = uint8(name[i])
   309  	}
   310  	// length is family (uint16), name, NUL.
   311  	sl := _Socklen(2)
   312  	if n > 0 {
   313  		sl += _Socklen(n) + 1
   314  	}
   315  
   316  	return unsafe.Pointer(&sa.raw), sl, nil
   317  }
   318  
   319  func Getsockname(fd int) (sa Sockaddr, err error) {
   320  	var rsa RawSockaddrAny
   321  	var len _Socklen = SizeofSockaddrAny
   322  	if err = getsockname(fd, &rsa, &len); err != nil {
   323  		return
   324  	}
   325  	return anyToSockaddr(&rsa)
   326  }
   327  
   328  //sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
   329  
   330  func Accept(fd int) (nfd int, sa Sockaddr, err error) {
   331  	var rsa RawSockaddrAny
   332  	var len _Socklen = SizeofSockaddrAny
   333  	nfd, err = accept(fd, &rsa, &len)
   334  	if err != nil {
   335  		return
   336  	}
   337  	sa, err = anyToSockaddr(&rsa)
   338  	if err != nil {
   339  		Close(nfd)
   340  		nfd = 0
   341  	}
   342  	return
   343  }
   344  
   345  func recvmsgRaw(fd int, p, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) {
   346  	var msg Msghdr
   347  	msg.Name = (*byte)(unsafe.Pointer(rsa))
   348  	msg.Namelen = uint32(SizeofSockaddrAny)
   349  	var iov Iovec
   350  	if len(p) > 0 {
   351  		iov.Base = &p[0]
   352  		iov.SetLen(len(p))
   353  	}
   354  	var dummy byte
   355  	if len(oob) > 0 {
   356  		var sockType int
   357  		sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
   358  		if err != nil {
   359  			return
   360  		}
   361  		// receive at least one normal byte
   362  		if sockType != SOCK_DGRAM && len(p) == 0 {
   363  			iov.Base = &dummy
   364  			iov.SetLen(1)
   365  		}
   366  		msg.Control = &oob[0]
   367  		msg.SetControllen(len(oob))
   368  	}
   369  	msg.Iov = &iov
   370  	msg.Iovlen = 1
   371  	if n, err = recvmsg(fd, &msg, flags); err != nil {
   372  		return
   373  	}
   374  	oobn = int(msg.Controllen)
   375  	recvflags = int(msg.Flags)
   376  	return
   377  }
   378  
   379  func sendmsgN(fd int, p, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
   380  	var msg Msghdr
   381  	msg.Name = (*byte)(ptr)
   382  	msg.Namelen = uint32(salen)
   383  	var iov Iovec
   384  	if len(p) > 0 {
   385  		iov.Base = &p[0]
   386  		iov.SetLen(len(p))
   387  	}
   388  	var dummy byte
   389  	if len(oob) > 0 {
   390  		var sockType int
   391  		sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
   392  		if err != nil {
   393  			return 0, err
   394  		}
   395  		// send at least one normal byte
   396  		if sockType != SOCK_DGRAM && len(p) == 0 {
   397  			iov.Base = &dummy
   398  			iov.SetLen(1)
   399  		}
   400  		msg.Control = &oob[0]
   401  		msg.SetControllen(len(oob))
   402  	}
   403  	msg.Iov = &iov
   404  	msg.Iovlen = 1
   405  	if n, err = sendmsg(fd, &msg, flags); err != nil {
   406  		return 0, err
   407  	}
   408  	if len(oob) > 0 && len(p) == 0 {
   409  		n = 0
   410  	}
   411  	return n, nil
   412  }
   413  
   414  func (sa *RawSockaddrUnix) getLen() (int, error) {
   415  	// Some versions of AIX have a bug in getsockname (see IV78655).
   416  	// We can't rely on sa.Len being set correctly.
   417  	n := SizeofSockaddrUnix - 3 // subtract leading Family, Len, terminating NUL.
   418  	for i := 0; i < n; i++ {
   419  		if sa.Path[i] == 0 {
   420  			n = i
   421  			break
   422  		}
   423  	}
   424  	return n, nil
   425  }
   426  
   427  func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) {
   428  	switch rsa.Addr.Family {
   429  	case AF_UNIX:
   430  		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
   431  		sa := new(SockaddrUnix)
   432  		n, err := pp.getLen()
   433  		if err != nil {
   434  			return nil, err
   435  		}
   436  		sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
   437  		return sa, nil
   438  
   439  	case AF_INET:
   440  		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
   441  		sa := new(SockaddrInet4)
   442  		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
   443  		sa.Port = int(p[0])<<8 + int(p[1])
   444  		sa.Addr = pp.Addr
   445  		return sa, nil
   446  
   447  	case AF_INET6:
   448  		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
   449  		sa := new(SockaddrInet6)
   450  		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
   451  		sa.Port = int(p[0])<<8 + int(p[1])
   452  		sa.Addr = pp.Addr
   453  		return sa, nil
   454  	}
   455  	return nil, EAFNOSUPPORT
   456  }
   457  
   458  type SockaddrDatalink struct {
   459  	Len    uint8
   460  	Family uint8
   461  	Index  uint16
   462  	Type   uint8
   463  	Nlen   uint8
   464  	Alen   uint8
   465  	Slen   uint8
   466  	Data   [120]uint8
   467  	raw    RawSockaddrDatalink
   468  }
   469  
   470  /*
   471   * Wait
   472   */
   473  
   474  type WaitStatus uint32
   475  
   476  func (w WaitStatus) Stopped() bool { return w&0x40 != 0 }
   477  func (w WaitStatus) StopSignal() Signal {
   478  	if !w.Stopped() {
   479  		return -1
   480  	}
   481  	return Signal(w>>8) & 0xFF
   482  }
   483  
   484  func (w WaitStatus) Exited() bool { return w&0xFF == 0 }
   485  func (w WaitStatus) ExitStatus() int {
   486  	if !w.Exited() {
   487  		return -1
   488  	}
   489  	return int((w >> 8) & 0xFF)
   490  }
   491  
   492  func (w WaitStatus) Signaled() bool { return w&0x40 == 0 && w&0xFF != 0 }
   493  func (w WaitStatus) Signal() Signal {
   494  	if !w.Signaled() {
   495  		return -1
   496  	}
   497  	return Signal(w>>16) & 0xFF
   498  }
   499  
   500  func (w WaitStatus) Continued() bool { return w&0x01000000 != 0 }
   501  
   502  func (w WaitStatus) CoreDump() bool { return w&0x80 == 0x80 }
   503  
   504  func (w WaitStatus) TrapCause() int { return -1 }
   505  
   506  /*
   507   * ptrace
   508   */
   509  
   510  //sys	Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
   511  //sys	ptrace64(request int, id int64, addr int64, data int, buff uintptr) (err error)
   512  //sys	ptrace64Ptr(request int, id int64, addr int64, data int, buff unsafe.Pointer) (err error) = ptrace64
   513  
   514  func raw_ptrace(request int, pid int, addr *byte, data *byte) Errno {
   515  	if request == PTRACE_TRACEME {
   516  		// Convert to AIX ptrace call.
   517  		err := ptrace64(PT_TRACE_ME, 0, 0, 0, 0)
   518  		if err != nil {
   519  			return err.(Errno)
   520  		}
   521  		return 0
   522  	}
   523  	return ENOSYS
   524  }
   525  
   526  func ptracePeek(pid int, addr uintptr, out []byte) (count int, err error) {
   527  	n := 0
   528  	for len(out) > 0 {
   529  		bsize := len(out)
   530  		if bsize > 1024 {
   531  			bsize = 1024
   532  		}
   533  		err = ptrace64Ptr(PT_READ_BLOCK, int64(pid), int64(addr), bsize, unsafe.Pointer(&out[0]))
   534  		if err != nil {
   535  			return 0, err
   536  		}
   537  		addr += uintptr(bsize)
   538  		n += bsize
   539  		out = out[n:]
   540  	}
   541  	return n, nil
   542  }
   543  
   544  func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
   545  	return ptracePeek(pid, addr, out)
   546  }
   547  
   548  func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
   549  	return ptracePeek(pid, addr, out)
   550  }
   551  
   552  func ptracePoke(pid int, addr uintptr, data []byte) (count int, err error) {
   553  	n := 0
   554  	for len(data) > 0 {
   555  		bsize := len(data)
   556  		if bsize > 1024 {
   557  			bsize = 1024
   558  		}
   559  		err = ptrace64Ptr(PT_WRITE_BLOCK, int64(pid), int64(addr), bsize, unsafe.Pointer(&data[0]))
   560  		if err != nil {
   561  			return 0, err
   562  		}
   563  		addr += uintptr(bsize)
   564  		n += bsize
   565  		data = data[n:]
   566  	}
   567  	return n, nil
   568  }
   569  
   570  func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
   571  	return ptracePoke(pid, addr, data)
   572  }
   573  
   574  func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
   575  	return ptracePoke(pid, addr, data)
   576  }
   577  
   578  func PtraceCont(pid int, signal int) (err error) {
   579  	return ptrace64(PT_CONTINUE, int64(pid), 1, signal, 0)
   580  }
   581  
   582  func PtraceSingleStep(pid int) (err error) { return ptrace64(PT_STEP, int64(pid), 1, 0, 0) }
   583  
   584  func PtraceAttach(pid int) (err error) { return ptrace64(PT_ATTACH, int64(pid), 0, 0, 0) }
   585  
   586  func PtraceDetach(pid int) (err error) { return ptrace64(PT_DETACH, int64(pid), 0, 0, 0) }
   587  
   588  /*
   589   * Direct access
   590   */
   591  
   592  //sys	Acct(path string) (err error)
   593  //sys	Chdir(path string) (err error)
   594  //sys	Chmod(path string, mode uint32) (err error)
   595  //sys	Chown(path string, uid int, gid int) (err error)
   596  //sys	Chroot(path string) (err error)
   597  //sys	Close(fd int) (err error)
   598  //sys	Dup(fd int) (nfd int, err error)
   599  //sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
   600  //sys	Fchdir(fd int) (err error)
   601  //sys	Fchmod(fd int, mode uint32) (err error)
   602  //sys	Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
   603  //sys	Fchown(fd int, uid int, gid int) (err error)
   604  //sys	Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
   605  //sys	Fpathconf(fd int, name int) (val int, err error)
   606  //sys	Fstat(fd int, stat *Stat_t) (err error)
   607  //sys	Fstatfs(fd int, buf *Statfs_t) (err error)
   608  //sys	Ftruncate(fd int, length int64) (err error)
   609  //sysnb	Getgid() (gid int)
   610  //sysnb	Getpid() (pid int)
   611  //sys	Geteuid() (euid int)
   612  //sys	Getegid() (egid int)
   613  //sys	Getppid() (ppid int)
   614  //sys	Getpriority(which int, who int) (n int, err error)
   615  //sysnb	Getrlimit(which int, lim *Rlimit) (err error)
   616  //sysnb	Getrusage(who int, rusage *Rusage) (err error)
   617  //sysnb	Getuid() (uid int)
   618  //sys	Kill(pid int, signum Signal) (err error)
   619  //sys	Lchown(path string, uid int, gid int) (err error)
   620  //sys	Link(path string, link string) (err error)
   621  //sys	Lstat(path string, stat *Stat_t) (err error)
   622  //sys	Mkdir(path string, mode uint32) (err error)
   623  //sys	Mkdirat(dirfd int, path string, mode uint32) (err error)
   624  //sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
   625  //sys	Open(path string, mode int, perm uint32) (fd int, err error)
   626  //sys	pread(fd int, p []byte, offset int64) (n int, err error)
   627  //sys	pwrite(fd int, p []byte, offset int64) (n int, err error)
   628  //sys	read(fd int, p []byte) (n int, err error)
   629  //sys	Reboot(how int) (err error)
   630  //sys	Rename(from string, to string) (err error)
   631  //sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
   632  //sys	Rmdir(path string) (err error)
   633  //sys	Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek
   634  //sysnb	Setegid(egid int) (err error)
   635  //sysnb	Seteuid(euid int) (err error)
   636  //sysnb	Setgid(gid int) (err error)
   637  //sysnb	Setuid(uid int) (err error)
   638  //sysnb	Setpgid(pid int, pgid int) (err error)
   639  //sys	Setpriority(which int, who int, prio int) (err error)
   640  //sysnb	Setregid(rgid int, egid int) (err error)
   641  //sysnb	Setreuid(ruid int, euid int) (err error)
   642  //sysnb	setrlimit(which int, lim *Rlimit) (err error)
   643  //sys	Stat(path string, stat *Stat_t) (err error)
   644  //sys	Statfs(path string, buf *Statfs_t) (err error)
   645  //sys	Symlink(path string, link string) (err error)
   646  //sys	Truncate(path string, length int64) (err error)
   647  //sys	Umask(newmask int) (oldmask int)
   648  //sys	Unlink(path string) (err error)
   649  //sysnb	Uname(buf *Utsname) (err error)
   650  //sys	write(fd int, p []byte) (n int, err error)
   651  //sys	writev(fd int, iovecs []Iovec) (n uintptr, err error)
   652  
   653  //sys	gettimeofday(tv *Timeval, tzp *Timezone) (err error)
   654  
   655  func setTimespec(sec, nsec int64) Timespec {
   656  	return Timespec{Sec: sec, Nsec: nsec}
   657  }
   658  
   659  func setTimeval(sec, usec int64) Timeval {
   660  	return Timeval{Sec: sec, Usec: int32(usec)}
   661  }
   662  
   663  func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
   664  	r0, _, e1 := syscall6(uintptr(unsafe.Pointer(&libc_read)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
   665  	n = int(r0)
   666  	if e1 != 0 {
   667  		err = e1
   668  	}
   669  	return
   670  }
   671  
   672  /*
   673   * Map
   674   */
   675  
   676  var mapper = &mmapper{
   677  	active: make(map[*byte][]byte),
   678  	mmap:   mmap,
   679  	munmap: munmap,
   680  }
   681  
   682  //sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
   683  //sys	munmap(addr uintptr, length uintptr) (err error)
   684  
   685  func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
   686  	return mapper.Mmap(fd, offset, length, prot, flags)
   687  }
   688  
   689  func Munmap(b []byte) (err error) {
   690  	return mapper.Munmap(b)
   691  }
   692  

View as plain text