Black Lives Matter. Support the Equal Justice Initiative.

Source file src/syscall/syscall_aix.go

Documentation: syscall

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