github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/sys/unix/syscall_linux_386.go (about)

     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  // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
     6  // so that go vet can check that they are correct.
     7  
     8  // +build 386,linux
     9  
    10  package unix
    11  
    12  import (
    13  	"syscall"
    14  	"unsafe"
    15  )
    16  
    17  func Getpagesize() int { return 4096 }
    18  
    19  func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
    20  
    21  func NsecToTimespec(nsec int64) (ts Timespec) {
    22  	ts.Sec = int32(nsec / 1e9)
    23  	ts.Nsec = int32(nsec % 1e9)
    24  	return
    25  }
    26  
    27  func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
    28  
    29  func NsecToTimeval(nsec int64) (tv Timeval) {
    30  	nsec += 999 // round up to microsecond
    31  	tv.Sec = int32(nsec / 1e9)
    32  	tv.Usec = int32(nsec % 1e9 / 1e3)
    33  	return
    34  }
    35  
    36  //sysnb	pipe(p *[2]_C_int) (err error)
    37  
    38  func Pipe(p []int) (err error) {
    39  	if len(p) != 2 {
    40  		return EINVAL
    41  	}
    42  	var pp [2]_C_int
    43  	err = pipe(&pp)
    44  	p[0] = int(pp[0])
    45  	p[1] = int(pp[1])
    46  	return
    47  }
    48  
    49  //sysnb pipe2(p *[2]_C_int, flags int) (err error)
    50  
    51  func Pipe2(p []int, flags int) (err error) {
    52  	if len(p) != 2 {
    53  		return EINVAL
    54  	}
    55  	var pp [2]_C_int
    56  	err = pipe2(&pp, flags)
    57  	p[0] = int(pp[0])
    58  	p[1] = int(pp[1])
    59  	return
    60  }
    61  
    62  // 64-bit file system and 32-bit uid calls
    63  // (386 default is 32-bit file system and 16-bit uid).
    64  //sys	Dup2(oldfd int, newfd int) (err error)
    65  //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64_64
    66  //sys	Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32
    67  //sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
    68  //sys	Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
    69  //sysnb	Getegid() (egid int) = SYS_GETEGID32
    70  //sysnb	Geteuid() (euid int) = SYS_GETEUID32
    71  //sysnb	Getgid() (gid int) = SYS_GETGID32
    72  //sysnb	Getuid() (uid int) = SYS_GETUID32
    73  //sysnb	InotifyInit() (fd int, err error)
    74  //sys	Ioperm(from int, num int, on int) (err error)
    75  //sys	Iopl(level int) (err error)
    76  //sys	Lchown(path string, uid int, gid int) (err error) = SYS_LCHOWN32
    77  //sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
    78  //sys	Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
    79  //sys	Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
    80  //sys	sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = SYS_SENDFILE64
    81  //sys	Setfsgid(gid int) (err error) = SYS_SETFSGID32
    82  //sys	Setfsuid(uid int) (err error) = SYS_SETFSUID32
    83  //sysnb	Setregid(rgid int, egid int) (err error) = SYS_SETREGID32
    84  //sysnb	Setresgid(rgid int, egid int, sgid int) (err error) = SYS_SETRESGID32
    85  //sysnb	Setresuid(ruid int, euid int, suid int) (err error) = SYS_SETRESUID32
    86  //sysnb	Setreuid(ruid int, euid int) (err error) = SYS_SETREUID32
    87  //sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
    88  //sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
    89  //sys	SyncFileRange(fd int, off int64, n int64, flags int) (err error)
    90  //sys	Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
    91  //sysnb	getgroups(n int, list *_Gid_t) (nn int, err error) = SYS_GETGROUPS32
    92  //sysnb	setgroups(n int, list *_Gid_t) (err error) = SYS_SETGROUPS32
    93  //sys	Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) = SYS__NEWSELECT
    94  
    95  //sys	mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error)
    96  
    97  func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
    98  	page := uintptr(offset / 4096)
    99  	if offset != int64(page)*4096 {
   100  		return 0, EINVAL
   101  	}
   102  	return mmap2(addr, length, prot, flags, fd, page)
   103  }
   104  
   105  type rlimit32 struct {
   106  	Cur uint32
   107  	Max uint32
   108  }
   109  
   110  //sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
   111  
   112  const rlimInf32 = ^uint32(0)
   113  const rlimInf64 = ^uint64(0)
   114  
   115  func Getrlimit(resource int, rlim *Rlimit) (err error) {
   116  	err = prlimit(0, resource, nil, rlim)
   117  	if err != ENOSYS {
   118  		return err
   119  	}
   120  
   121  	rl := rlimit32{}
   122  	err = getrlimit(resource, &rl)
   123  	if err != nil {
   124  		return
   125  	}
   126  
   127  	if rl.Cur == rlimInf32 {
   128  		rlim.Cur = rlimInf64
   129  	} else {
   130  		rlim.Cur = uint64(rl.Cur)
   131  	}
   132  
   133  	if rl.Max == rlimInf32 {
   134  		rlim.Max = rlimInf64
   135  	} else {
   136  		rlim.Max = uint64(rl.Max)
   137  	}
   138  	return
   139  }
   140  
   141  //sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
   142  
   143  func Setrlimit(resource int, rlim *Rlimit) (err error) {
   144  	err = prlimit(0, resource, rlim, nil)
   145  	if err != ENOSYS {
   146  		return err
   147  	}
   148  
   149  	rl := rlimit32{}
   150  	if rlim.Cur == rlimInf64 {
   151  		rl.Cur = rlimInf32
   152  	} else if rlim.Cur < uint64(rlimInf32) {
   153  		rl.Cur = uint32(rlim.Cur)
   154  	} else {
   155  		return EINVAL
   156  	}
   157  	if rlim.Max == rlimInf64 {
   158  		rl.Max = rlimInf32
   159  	} else if rlim.Max < uint64(rlimInf32) {
   160  		rl.Max = uint32(rlim.Max)
   161  	} else {
   162  		return EINVAL
   163  	}
   164  
   165  	return setrlimit(resource, &rl)
   166  }
   167  
   168  // Underlying system call writes to newoffset via pointer.
   169  // Implemented in assembly to avoid allocation.
   170  func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)
   171  
   172  func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
   173  	newoffset, errno := seek(fd, offset, whence)
   174  	if errno != 0 {
   175  		return 0, errno
   176  	}
   177  	return newoffset, nil
   178  }
   179  
   180  // Vsyscalls on amd64.
   181  //sysnb	Gettimeofday(tv *Timeval) (err error)
   182  //sysnb	Time(t *Time_t) (tt Time_t, err error)
   183  
   184  // On x86 Linux, all the socket calls go through an extra indirection,
   185  // I think because the 5-register system call interface can't handle
   186  // the 6-argument calls like sendto and recvfrom.  Instead the
   187  // arguments to the underlying system call are the number below
   188  // and a pointer to an array of uintptr.  We hide the pointer in the
   189  // socketcall assembly to avoid allocation on every system call.
   190  
   191  const (
   192  	// see linux/net.h
   193  	_SOCKET      = 1
   194  	_BIND        = 2
   195  	_CONNECT     = 3
   196  	_LISTEN      = 4
   197  	_ACCEPT      = 5
   198  	_GETSOCKNAME = 6
   199  	_GETPEERNAME = 7
   200  	_SOCKETPAIR  = 8
   201  	_SEND        = 9
   202  	_RECV        = 10
   203  	_SENDTO      = 11
   204  	_RECVFROM    = 12
   205  	_SHUTDOWN    = 13
   206  	_SETSOCKOPT  = 14
   207  	_GETSOCKOPT  = 15
   208  	_SENDMSG     = 16
   209  	_RECVMSG     = 17
   210  	_ACCEPT4     = 18
   211  	_RECVMMSG    = 19
   212  	_SENDMMSG    = 20
   213  )
   214  
   215  func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
   216  func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
   217  
   218  func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
   219  	fd, e := socketcall(_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
   220  	if e != 0 {
   221  		err = e
   222  	}
   223  	return
   224  }
   225  
   226  func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
   227  	fd, e := socketcall(_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
   228  	if e != 0 {
   229  		err = e
   230  	}
   231  	return
   232  }
   233  
   234  func getsockname(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
   235  	_, e := rawsocketcall(_GETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
   236  	if e != 0 {
   237  		err = e
   238  	}
   239  	return
   240  }
   241  
   242  func getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
   243  	_, e := rawsocketcall(_GETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
   244  	if e != 0 {
   245  		err = e
   246  	}
   247  	return
   248  }
   249  
   250  func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
   251  	_, e := rawsocketcall(_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
   252  	if e != 0 {
   253  		err = e
   254  	}
   255  	return
   256  }
   257  
   258  func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
   259  	_, e := socketcall(_BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
   260  	if e != 0 {
   261  		err = e
   262  	}
   263  	return
   264  }
   265  
   266  func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
   267  	_, e := socketcall(_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
   268  	if e != 0 {
   269  		err = e
   270  	}
   271  	return
   272  }
   273  
   274  func socket(domain int, typ int, proto int) (fd int, err error) {
   275  	fd, e := rawsocketcall(_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0)
   276  	if e != 0 {
   277  		err = e
   278  	}
   279  	return
   280  }
   281  
   282  func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
   283  	_, e := socketcall(_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
   284  	if e != 0 {
   285  		err = e
   286  	}
   287  	return
   288  }
   289  
   290  func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
   291  	_, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0)
   292  	if e != 0 {
   293  		err = e
   294  	}
   295  	return
   296  }
   297  
   298  func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
   299  	var base uintptr
   300  	if len(p) > 0 {
   301  		base = uintptr(unsafe.Pointer(&p[0]))
   302  	}
   303  	n, e := socketcall(_RECVFROM, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
   304  	if e != 0 {
   305  		err = e
   306  	}
   307  	return
   308  }
   309  
   310  func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
   311  	var base uintptr
   312  	if len(p) > 0 {
   313  		base = uintptr(unsafe.Pointer(&p[0]))
   314  	}
   315  	_, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen))
   316  	if e != 0 {
   317  		err = e
   318  	}
   319  	return
   320  }
   321  
   322  func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
   323  	n, e := socketcall(_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
   324  	if e != 0 {
   325  		err = e
   326  	}
   327  	return
   328  }
   329  
   330  func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
   331  	n, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
   332  	if e != 0 {
   333  		err = e
   334  	}
   335  	return
   336  }
   337  
   338  func Listen(s int, n int) (err error) {
   339  	_, e := socketcall(_LISTEN, uintptr(s), uintptr(n), 0, 0, 0, 0)
   340  	if e != 0 {
   341  		err = e
   342  	}
   343  	return
   344  }
   345  
   346  func Shutdown(s, how int) (err error) {
   347  	_, e := socketcall(_SHUTDOWN, uintptr(s), uintptr(how), 0, 0, 0, 0)
   348  	if e != 0 {
   349  		err = e
   350  	}
   351  	return
   352  }
   353  
   354  func Fstatfs(fd int, buf *Statfs_t) (err error) {
   355  	_, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
   356  	if e != 0 {
   357  		err = e
   358  	}
   359  	return
   360  }
   361  
   362  func Statfs(path string, buf *Statfs_t) (err error) {
   363  	pathp, err := BytePtrFromString(path)
   364  	if err != nil {
   365  		return err
   366  	}
   367  	_, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
   368  	if e != 0 {
   369  		err = e
   370  	}
   371  	return
   372  }
   373  
   374  func (r *PtraceRegs) PC() uint64 { return uint64(uint32(r.Eip)) }
   375  
   376  func (r *PtraceRegs) SetPC(pc uint64) { r.Eip = int32(pc) }
   377  
   378  func (iov *Iovec) SetLen(length int) {
   379  	iov.Len = uint32(length)
   380  }
   381  
   382  func (msghdr *Msghdr) SetControllen(length int) {
   383  	msghdr.Controllen = uint32(length)
   384  }
   385  
   386  func (cmsg *Cmsghdr) SetLen(length int) {
   387  	cmsg.Len = uint32(length)
   388  }