Source file src/pkg/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go

     1	// Copyright 2009 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	// Solaris 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 wrap
    10	// it in our own nicer implementation, either here or in
    11	// syscall_solaris.go or syscall_unix.go.
    12	
    13	package unix
    14	
    15	import (
    16		"syscall"
    17		"unsafe"
    18	)
    19	
    20	// Implemented in runtime/syscall_solaris.go.
    21	type syscallFunc uintptr
    22	
    23	func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
    24	func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
    25	
    26	// SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
    27	type SockaddrDatalink struct {
    28		Family uint16
    29		Index  uint16
    30		Type   uint8
    31		Nlen   uint8
    32		Alen   uint8
    33		Slen   uint8
    34		Data   [244]int8
    35		raw    RawSockaddrDatalink
    36	}
    37	
    38	//sysnb	pipe(p *[2]_C_int) (n int, err error)
    39	
    40	func Pipe(p []int) (err error) {
    41		if len(p) != 2 {
    42			return EINVAL
    43		}
    44		var pp [2]_C_int
    45		n, err := pipe(&pp)
    46		if n != 0 {
    47			return err
    48		}
    49		p[0] = int(pp[0])
    50		p[1] = int(pp[1])
    51		return nil
    52	}
    53	
    54	func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
    55		if sa.Port < 0 || sa.Port > 0xFFFF {
    56			return nil, 0, EINVAL
    57		}
    58		sa.raw.Family = AF_INET
    59		p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
    60		p[0] = byte(sa.Port >> 8)
    61		p[1] = byte(sa.Port)
    62		for i := 0; i < len(sa.Addr); i++ {
    63			sa.raw.Addr[i] = sa.Addr[i]
    64		}
    65		return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
    66	}
    67	
    68	func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
    69		if sa.Port < 0 || sa.Port > 0xFFFF {
    70			return nil, 0, EINVAL
    71		}
    72		sa.raw.Family = AF_INET6
    73		p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
    74		p[0] = byte(sa.Port >> 8)
    75		p[1] = byte(sa.Port)
    76		sa.raw.Scope_id = sa.ZoneId
    77		for i := 0; i < len(sa.Addr); i++ {
    78			sa.raw.Addr[i] = sa.Addr[i]
    79		}
    80		return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
    81	}
    82	
    83	func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
    84		name := sa.Name
    85		n := len(name)
    86		if n >= len(sa.raw.Path) {
    87			return nil, 0, EINVAL
    88		}
    89		sa.raw.Family = AF_UNIX
    90		for i := 0; i < n; i++ {
    91			sa.raw.Path[i] = int8(name[i])
    92		}
    93		// length is family (uint16), name, NUL.
    94		sl := _Socklen(2)
    95		if n > 0 {
    96			sl += _Socklen(n) + 1
    97		}
    98		if sa.raw.Path[0] == '@' {
    99			sa.raw.Path[0] = 0
   100			// Don't count trailing NUL for abstract address.
   101			sl--
   102		}
   103	
   104		return unsafe.Pointer(&sa.raw), sl, nil
   105	}
   106	
   107	//sys	getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname
   108	
   109	func Getsockname(fd int) (sa Sockaddr, err error) {
   110		var rsa RawSockaddrAny
   111		var len _Socklen = SizeofSockaddrAny
   112		if err = getsockname(fd, &rsa, &len); err != nil {
   113			return
   114		}
   115		return anyToSockaddr(fd, &rsa)
   116	}
   117	
   118	// GetsockoptString returns the string value of the socket option opt for the
   119	// socket associated with fd at the given socket level.
   120	func GetsockoptString(fd, level, opt int) (string, error) {
   121		buf := make([]byte, 256)
   122		vallen := _Socklen(len(buf))
   123		err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
   124		if err != nil {
   125			return "", err
   126		}
   127		return string(buf[:vallen-1]), nil
   128	}
   129	
   130	const ImplementsGetwd = true
   131	
   132	//sys	Getcwd(buf []byte) (n int, err error)
   133	
   134	func Getwd() (wd string, err error) {
   135		var buf [PathMax]byte
   136		// Getcwd will return an error if it failed for any reason.
   137		_, err = Getcwd(buf[0:])
   138		if err != nil {
   139			return "", err
   140		}
   141		n := clen(buf[:])
   142		if n < 1 {
   143			return "", EINVAL
   144		}
   145		return string(buf[:n]), nil
   146	}
   147	
   148	/*
   149	 * Wrapped
   150	 */
   151	
   152	//sysnb	getgroups(ngid int, gid *_Gid_t) (n int, err error)
   153	//sysnb	setgroups(ngid int, gid *_Gid_t) (err error)
   154	
   155	func Getgroups() (gids []int, err error) {
   156		n, err := getgroups(0, nil)
   157		// Check for error and sanity check group count. Newer versions of
   158		// Solaris allow up to 1024 (NGROUPS_MAX).
   159		if n < 0 || n > 1024 {
   160			if err != nil {
   161				return nil, err
   162			}
   163			return nil, EINVAL
   164		} else if n == 0 {
   165			return nil, nil
   166		}
   167	
   168		a := make([]_Gid_t, n)
   169		n, err = getgroups(n, &a[0])
   170		if n == -1 {
   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 ReadDirent(fd int, buf []byte) (n int, err error) {
   193		// Final argument is (basep *uintptr) and the syscall doesn't take nil.
   194		// TODO(rsc): Can we use a single global basep for all calls?
   195		return Getdents(fd, buf, new(uintptr))
   196	}
   197	
   198	// Wait status is 7 bits at bottom, either 0 (exited),
   199	// 0x7F (stopped), or a signal number that caused an exit.
   200	// The 0x80 bit is whether there was a core dump.
   201	// An extra number (exit code, signal causing a stop)
   202	// is in the high bits.
   203	
   204	type WaitStatus uint32
   205	
   206	const (
   207		mask  = 0x7F
   208		core  = 0x80
   209		shift = 8
   210	
   211		exited  = 0
   212		stopped = 0x7F
   213	)
   214	
   215	func (w WaitStatus) Exited() bool { return w&mask == exited }
   216	
   217	func (w WaitStatus) ExitStatus() int {
   218		if w&mask != exited {
   219			return -1
   220		}
   221		return int(w >> shift)
   222	}
   223	
   224	func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
   225	
   226	func (w WaitStatus) Signal() syscall.Signal {
   227		sig := syscall.Signal(w & mask)
   228		if sig == stopped || sig == 0 {
   229			return -1
   230		}
   231		return sig
   232	}
   233	
   234	func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
   235	
   236	func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP }
   237	
   238	func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }
   239	
   240	func (w WaitStatus) StopSignal() syscall.Signal {
   241		if !w.Stopped() {
   242			return -1
   243		}
   244		return syscall.Signal(w>>shift) & 0xFF
   245	}
   246	
   247	func (w WaitStatus) TrapCause() int { return -1 }
   248	
   249	//sys	wait4(pid int32, statusp *_C_int, options int, rusage *Rusage) (wpid int32, err error)
   250	
   251	func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (int, error) {
   252		var status _C_int
   253		rpid, err := wait4(int32(pid), &status, options, rusage)
   254		wpid := int(rpid)
   255		if wpid == -1 {
   256			return wpid, err
   257		}
   258		if wstatus != nil {
   259			*wstatus = WaitStatus(status)
   260		}
   261		return wpid, nil
   262	}
   263	
   264	//sys	gethostname(buf []byte) (n int, err error)
   265	
   266	func Gethostname() (name string, err error) {
   267		var buf [MaxHostNameLen]byte
   268		n, err := gethostname(buf[:])
   269		if n != 0 {
   270			return "", err
   271		}
   272		n = clen(buf[:])
   273		if n < 1 {
   274			return "", EFAULT
   275		}
   276		return string(buf[:n]), nil
   277	}
   278	
   279	//sys	utimes(path string, times *[2]Timeval) (err error)
   280	
   281	func Utimes(path string, tv []Timeval) (err error) {
   282		if tv == nil {
   283			return utimes(path, nil)
   284		}
   285		if len(tv) != 2 {
   286			return EINVAL
   287		}
   288		return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
   289	}
   290	
   291	//sys	utimensat(fd int, path string, times *[2]Timespec, flag int) (err error)
   292	
   293	func UtimesNano(path string, ts []Timespec) error {
   294		if ts == nil {
   295			return utimensat(AT_FDCWD, path, nil, 0)
   296		}
   297		if len(ts) != 2 {
   298			return EINVAL
   299		}
   300		return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
   301	}
   302	
   303	func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
   304		if ts == nil {
   305			return utimensat(dirfd, path, nil, flags)
   306		}
   307		if len(ts) != 2 {
   308			return EINVAL
   309		}
   310		return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
   311	}
   312	
   313	//sys	fcntl(fd int, cmd int, arg int) (val int, err error)
   314	
   315	// FcntlInt performs a fcntl syscall on fd with the provided command and argument.
   316	func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
   317		valptr, _, errno := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
   318		var err error
   319		if errno != 0 {
   320			err = errno
   321		}
   322		return int(valptr), err
   323	}
   324	
   325	// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
   326	func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
   327		_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0)
   328		if e1 != 0 {
   329			return e1
   330		}
   331		return nil
   332	}
   333	
   334	//sys	futimesat(fildes int, path *byte, times *[2]Timeval) (err error)
   335	
   336	func Futimesat(dirfd int, path string, tv []Timeval) error {
   337		pathp, err := BytePtrFromString(path)
   338		if err != nil {
   339			return err
   340		}
   341		if tv == nil {
   342			return futimesat(dirfd, pathp, nil)
   343		}
   344		if len(tv) != 2 {
   345			return EINVAL
   346		}
   347		return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
   348	}
   349	
   350	// Solaris doesn't have an futimes function because it allows NULL to be
   351	// specified as the path for futimesat. However, Go doesn't like
   352	// NULL-style string interfaces, so this simple wrapper is provided.
   353	func Futimes(fd int, tv []Timeval) error {
   354		if tv == nil {
   355			return futimesat(fd, nil, nil)
   356		}
   357		if len(tv) != 2 {
   358			return EINVAL
   359		}
   360		return futimesat(fd, nil, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
   361	}
   362	
   363	func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
   364		switch rsa.Addr.Family {
   365		case AF_UNIX:
   366			pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
   367			sa := new(SockaddrUnix)
   368			// Assume path ends at NUL.
   369			// This is not technically the Solaris semantics for
   370			// abstract Unix domain sockets -- they are supposed
   371			// to be uninterpreted fixed-size binary blobs -- but
   372			// everyone uses this convention.
   373			n := 0
   374			for n < len(pp.Path) && pp.Path[n] != 0 {
   375				n++
   376			}
   377			bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
   378			sa.Name = string(bytes)
   379			return sa, nil
   380	
   381		case AF_INET:
   382			pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
   383			sa := new(SockaddrInet4)
   384			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
   385			sa.Port = int(p[0])<<8 + int(p[1])
   386			for i := 0; i < len(sa.Addr); i++ {
   387				sa.Addr[i] = pp.Addr[i]
   388			}
   389			return sa, nil
   390	
   391		case AF_INET6:
   392			pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
   393			sa := new(SockaddrInet6)
   394			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
   395			sa.Port = int(p[0])<<8 + int(p[1])
   396			sa.ZoneId = pp.Scope_id
   397			for i := 0; i < len(sa.Addr); i++ {
   398				sa.Addr[i] = pp.Addr[i]
   399			}
   400			return sa, nil
   401		}
   402		return nil, EAFNOSUPPORT
   403	}
   404	
   405	//sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept
   406	
   407	func Accept(fd int) (nfd int, sa Sockaddr, err error) {
   408		var rsa RawSockaddrAny
   409		var len _Socklen = SizeofSockaddrAny
   410		nfd, err = accept(fd, &rsa, &len)
   411		if nfd == -1 {
   412			return
   413		}
   414		sa, err = anyToSockaddr(fd, &rsa)
   415		if err != nil {
   416			Close(nfd)
   417			nfd = 0
   418		}
   419		return
   420	}
   421	
   422	//sys	recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_recvmsg
   423	
   424	func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
   425		var msg Msghdr
   426		var rsa RawSockaddrAny
   427		msg.Name = (*byte)(unsafe.Pointer(&rsa))
   428		msg.Namelen = uint32(SizeofSockaddrAny)
   429		var iov Iovec
   430		if len(p) > 0 {
   431			iov.Base = (*int8)(unsafe.Pointer(&p[0]))
   432			iov.SetLen(len(p))
   433		}
   434		var dummy int8
   435		if len(oob) > 0 {
   436			// receive at least one normal byte
   437			if len(p) == 0 {
   438				iov.Base = &dummy
   439				iov.SetLen(1)
   440			}
   441			msg.Accrightslen = int32(len(oob))
   442		}
   443		msg.Iov = &iov
   444		msg.Iovlen = 1
   445		if n, err = recvmsg(fd, &msg, flags); n == -1 {
   446			return
   447		}
   448		oobn = int(msg.Accrightslen)
   449		// source address is only specified if the socket is unconnected
   450		if rsa.Addr.Family != AF_UNSPEC {
   451			from, err = anyToSockaddr(fd, &rsa)
   452		}
   453		return
   454	}
   455	
   456	func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
   457		_, err = SendmsgN(fd, p, oob, to, flags)
   458		return
   459	}
   460	
   461	//sys	sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_sendmsg
   462	
   463	func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
   464		var ptr unsafe.Pointer
   465		var salen _Socklen
   466		if to != nil {
   467			ptr, salen, err = to.sockaddr()
   468			if err != nil {
   469				return 0, err
   470			}
   471		}
   472		var msg Msghdr
   473		msg.Name = (*byte)(unsafe.Pointer(ptr))
   474		msg.Namelen = uint32(salen)
   475		var iov Iovec
   476		if len(p) > 0 {
   477			iov.Base = (*int8)(unsafe.Pointer(&p[0]))
   478			iov.SetLen(len(p))
   479		}
   480		var dummy int8
   481		if len(oob) > 0 {
   482			// send at least one normal byte
   483			if len(p) == 0 {
   484				iov.Base = &dummy
   485				iov.SetLen(1)
   486			}
   487			msg.Accrightslen = int32(len(oob))
   488		}
   489		msg.Iov = &iov
   490		msg.Iovlen = 1
   491		if n, err = sendmsg(fd, &msg, flags); err != nil {
   492			return 0, err
   493		}
   494		if len(oob) > 0 && len(p) == 0 {
   495			n = 0
   496		}
   497		return n, nil
   498	}
   499	
   500	//sys	acct(path *byte) (err error)
   501	
   502	func Acct(path string) (err error) {
   503		if len(path) == 0 {
   504			// Assume caller wants to disable accounting.
   505			return acct(nil)
   506		}
   507	
   508		pathp, err := BytePtrFromString(path)
   509		if err != nil {
   510			return err
   511		}
   512		return acct(pathp)
   513	}
   514	
   515	//sys	__makedev(version int, major uint, minor uint) (val uint64)
   516	
   517	func Mkdev(major, minor uint32) uint64 {
   518		return __makedev(NEWDEV, uint(major), uint(minor))
   519	}
   520	
   521	//sys	__major(version int, dev uint64) (val uint)
   522	
   523	func Major(dev uint64) uint32 {
   524		return uint32(__major(NEWDEV, dev))
   525	}
   526	
   527	//sys	__minor(version int, dev uint64) (val uint)
   528	
   529	func Minor(dev uint64) uint32 {
   530		return uint32(__minor(NEWDEV, dev))
   531	}
   532	
   533	/*
   534	 * Expose the ioctl function
   535	 */
   536	
   537	//sys	ioctl(fd int, req uint, arg uintptr) (err error)
   538	
   539	func IoctlSetInt(fd int, req uint, value int) (err error) {
   540		return ioctl(fd, req, uintptr(value))
   541	}
   542	
   543	func ioctlSetWinsize(fd int, req uint, value *Winsize) (err error) {
   544		return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
   545	}
   546	
   547	func ioctlSetTermios(fd int, req uint, value *Termios) (err error) {
   548		return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
   549	}
   550	
   551	func IoctlSetTermio(fd int, req uint, value *Termio) (err error) {
   552		return ioctl(fd, req, uintptr(unsafe.Pointer(value)))
   553	}
   554	
   555	func IoctlGetInt(fd int, req uint) (int, error) {
   556		var value int
   557		err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
   558		return value, err
   559	}
   560	
   561	func IoctlGetWinsize(fd int, req uint) (*Winsize, error) {
   562		var value Winsize
   563		err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
   564		return &value, err
   565	}
   566	
   567	func IoctlGetTermios(fd int, req uint) (*Termios, error) {
   568		var value Termios
   569		err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
   570		return &value, err
   571	}
   572	
   573	func IoctlGetTermio(fd int, req uint) (*Termio, error) {
   574		var value Termio
   575		err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
   576		return &value, err
   577	}
   578	
   579	//sys   poll(fds *PollFd, nfds int, timeout int) (n int, err error)
   580	
   581	func Poll(fds []PollFd, timeout int) (n int, err error) {
   582		if len(fds) == 0 {
   583			return poll(nil, 0, timeout)
   584		}
   585		return poll(&fds[0], len(fds), timeout)
   586	}
   587	
   588	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
   589		if raceenabled {
   590			raceReleaseMerge(unsafe.Pointer(&ioSync))
   591		}
   592		return sendfile(outfd, infd, offset, count)
   593	}
   594	
   595	/*
   596	 * Exposed directly
   597	 */
   598	//sys	Access(path string, mode uint32) (err error)
   599	//sys	Adjtime(delta *Timeval, olddelta *Timeval) (err error)
   600	//sys	Chdir(path string) (err error)
   601	//sys	Chmod(path string, mode uint32) (err error)
   602	//sys	Chown(path string, uid int, gid int) (err error)
   603	//sys	Chroot(path string) (err error)
   604	//sys	Close(fd int) (err error)
   605	//sys	Creat(path string, mode uint32) (fd int, err error)
   606	//sys	Dup(fd int) (nfd int, err error)
   607	//sys	Dup2(oldfd int, newfd int) (err error)
   608	//sys	Exit(code int)
   609	//sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
   610	//sys	Fchdir(fd int) (err error)
   611	//sys	Fchmod(fd int, mode uint32) (err error)
   612	//sys	Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
   613	//sys	Fchown(fd int, uid int, gid int) (err error)
   614	//sys	Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
   615	//sys	Fdatasync(fd int) (err error)
   616	//sys	Flock(fd int, how int) (err error)
   617	//sys	Fpathconf(fd int, name int) (val int, err error)
   618	//sys	Fstat(fd int, stat *Stat_t) (err error)
   619	//sys	Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
   620	//sys	Fstatvfs(fd int, vfsstat *Statvfs_t) (err error)
   621	//sys	Getdents(fd int, buf []byte, basep *uintptr) (n int, err error)
   622	//sysnb	Getgid() (gid int)
   623	//sysnb	Getpid() (pid int)
   624	//sysnb	Getpgid(pid int) (pgid int, err error)
   625	//sysnb	Getpgrp() (pgid int, err error)
   626	//sys	Geteuid() (euid int)
   627	//sys	Getegid() (egid int)
   628	//sys	Getppid() (ppid int)
   629	//sys	Getpriority(which int, who int) (n int, err error)
   630	//sysnb	Getrlimit(which int, lim *Rlimit) (err error)
   631	//sysnb	Getrusage(who int, rusage *Rusage) (err error)
   632	//sysnb	Gettimeofday(tv *Timeval) (err error)
   633	//sysnb	Getuid() (uid int)
   634	//sys	Kill(pid int, signum syscall.Signal) (err error)
   635	//sys	Lchown(path string, uid int, gid int) (err error)
   636	//sys	Link(path string, link string) (err error)
   637	//sys	Listen(s int, backlog int) (err error) = libsocket.__xnet_llisten
   638	//sys	Lstat(path string, stat *Stat_t) (err error)
   639	//sys	Madvise(b []byte, advice int) (err error)
   640	//sys	Mkdir(path string, mode uint32) (err error)
   641	//sys	Mkdirat(dirfd int, path string, mode uint32) (err error)
   642	//sys	Mkfifo(path string, mode uint32) (err error)
   643	//sys	Mkfifoat(dirfd int, path string, mode uint32) (err error)
   644	//sys	Mknod(path string, mode uint32, dev int) (err error)
   645	//sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
   646	//sys	Mlock(b []byte) (err error)
   647	//sys	Mlockall(flags int) (err error)
   648	//sys	Mprotect(b []byte, prot int) (err error)
   649	//sys	Msync(b []byte, flags int) (err error)
   650	//sys	Munlock(b []byte) (err error)
   651	//sys	Munlockall() (err error)
   652	//sys	Nanosleep(time *Timespec, leftover *Timespec) (err error)
   653	//sys	Open(path string, mode int, perm uint32) (fd int, err error)
   654	//sys	Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
   655	//sys	Pathconf(path string, name int) (val int, err error)
   656	//sys	Pause() (err error)
   657	//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
   658	//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
   659	//sys	read(fd int, p []byte) (n int, err error)
   660	//sys	Readlink(path string, buf []byte) (n int, err error)
   661	//sys	Rename(from string, to string) (err error)
   662	//sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
   663	//sys	Rmdir(path string) (err error)
   664	//sys	Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek
   665	//sys	Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error)
   666	//sysnb	Setegid(egid int) (err error)
   667	//sysnb	Seteuid(euid int) (err error)
   668	//sysnb	Setgid(gid int) (err error)
   669	//sys	Sethostname(p []byte) (err error)
   670	//sysnb	Setpgid(pid int, pgid int) (err error)
   671	//sys	Setpriority(which int, who int, prio int) (err error)
   672	//sysnb	Setregid(rgid int, egid int) (err error)
   673	//sysnb	Setreuid(ruid int, euid int) (err error)
   674	//sysnb	Setrlimit(which int, lim *Rlimit) (err error)
   675	//sysnb	Setsid() (pid int, err error)
   676	//sysnb	Setuid(uid int) (err error)
   677	//sys	Shutdown(s int, how int) (err error) = libsocket.shutdown
   678	//sys	Stat(path string, stat *Stat_t) (err error)
   679	//sys	Statvfs(path string, vfsstat *Statvfs_t) (err error)
   680	//sys	Symlink(path string, link string) (err error)
   681	//sys	Sync() (err error)
   682	//sysnb	Times(tms *Tms) (ticks uintptr, err error)
   683	//sys	Truncate(path string, length int64) (err error)
   684	//sys	Fsync(fd int) (err error)
   685	//sys	Ftruncate(fd int, length int64) (err error)
   686	//sys	Umask(mask int) (oldmask int)
   687	//sysnb	Uname(buf *Utsname) (err error)
   688	//sys	Unmount(target string, flags int) (err error) = libc.umount
   689	//sys	Unlink(path string) (err error)
   690	//sys	Unlinkat(dirfd int, path string, flags int) (err error)
   691	//sys	Ustat(dev int, ubuf *Ustat_t) (err error)
   692	//sys	Utime(path string, buf *Utimbuf) (err error)
   693	//sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_bind
   694	//sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_connect
   695	//sys	mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
   696	//sys	munmap(addr uintptr, length uintptr) (err error)
   697	//sys	sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = libsendfile.sendfile
   698	//sys	sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_sendto
   699	//sys	socket(domain int, typ int, proto int) (fd int, err error) = libsocket.__xnet_socket
   700	//sysnb	socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.__xnet_socketpair
   701	//sys	write(fd int, p []byte) (n int, err error)
   702	//sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.__xnet_getsockopt
   703	//sysnb	getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername
   704	//sys	setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt
   705	//sys	recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom
   706	
   707	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
   708		r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procread)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
   709		n = int(r0)
   710		if e1 != 0 {
   711			err = e1
   712		}
   713		return
   714	}
   715	
   716	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
   717		r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procwrite)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0)
   718		n = int(r0)
   719		if e1 != 0 {
   720			err = e1
   721		}
   722		return
   723	}
   724	
   725	var mapper = &mmapper{
   726		active: make(map[*byte][]byte),
   727		mmap:   mmap,
   728		munmap: munmap,
   729	}
   730	
   731	func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
   732		return mapper.Mmap(fd, offset, length, prot, flags)
   733	}
   734	
   735	func Munmap(b []byte) (err error) {
   736		return mapper.Munmap(b)
   737	}
   738	

View as plain text