syscall_linux_386.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  package syscall
     6  
     7  import "unsafe"
     8  
     9  const (
    10  	_SYS_setgroups  = SYS_SETGROUPS32
    11  	_SYS_clone3     = 435
    12  	_SYS_faccessat2 = 439
    13  	_SYS_fchmodat2  = 452
    14  )
    15  
    16  func setTimespec(sec, nsec int64) Timespec {
    17  	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
    18  }
    19  
    20  func setTimeval(sec, usec int64) Timeval {
    21  	return Timeval{Sec: int32(sec), Usec: int32(usec)}
    22  }
    23  
    24  // 64-bit file system and 32-bit uid calls
    25  // (386 default is 32-bit file system and 16-bit uid).
    26  //sys	Dup2(oldfd int, newfd int) (err error)
    27  //sys	Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32
    28  //sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
    29  //sys	fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
    30  //sys	Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
    31  //sysnb	Getegid() (egid int) = SYS_GETEGID32
    32  //sysnb	Geteuid() (euid int) = SYS_GETEUID32
    33  //sysnb	Getgid() (gid int) = SYS_GETGID32
    34  //sysnb	Getuid() (uid int) = SYS_GETUID32
    35  //sysnb	InotifyInit() (fd int, err error)
    36  //sys	Ioperm(from int, num int, on int) (err error)
    37  //sys	Iopl(level int) (err error)
    38  //sys	Pause() (err error)
    39  //sys	pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
    40  //sys	pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
    41  //sys	Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
    42  //sys	sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = SYS_SENDFILE64
    43  //sys	Setfsgid(gid int) (err error) = SYS_SETFSGID32
    44  //sys	Setfsuid(uid int) (err error) = SYS_SETFSUID32
    45  //sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
    46  //sys	SyncFileRange(fd int, off int64, n int64, flags int) (err error)
    47  //sys	Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
    48  //sys	Ustat(dev int, ubuf *Ustat_t) (err error)
    49  //sysnb	getgroups(n int, list *_Gid_t) (nn int, err error) = SYS_GETGROUPS32
    50  //sys	Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) = SYS__NEWSELECT
    51  
    52  //sys	mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error)
    53  //sys	EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
    54  
    55  func Stat(path string, stat *Stat_t) (err error) {
    56  	return fstatat(_AT_FDCWD, path, stat, 0)
    57  }
    58  
    59  func Lchown(path string, uid int, gid int) (err error) {
    60  	return Fchownat(_AT_FDCWD, path, uid, gid, _AT_SYMLINK_NOFOLLOW)
    61  }
    62  
    63  func Lstat(path string, stat *Stat_t) (err error) {
    64  	return fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW)
    65  }
    66  
    67  func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
    68  	page := uintptr(offset / 4096)
    69  	if offset != int64(page)*4096 {
    70  		return 0, EINVAL
    71  	}
    72  	return mmap2(addr, length, prot, flags, fd, page)
    73  }
    74  
    75  // Underlying system call writes to newoffset via pointer.
    76  // Implemented in assembly to avoid allocation.
    77  //
    78  // Accessed via assembly in x/sys/unix.
    79  //
    80  //go:linkname seek
    81  func seek(fd int, offset int64, whence int) (newoffset int64, err Errno)
    82  
    83  func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
    84  	newoffset, errno := seek(fd, offset, whence)
    85  	if errno != 0 {
    86  		return 0, errno
    87  	}
    88  	return newoffset, nil
    89  }
    90  
    91  //sys	futimesat(dirfd int, path string, times *[2]Timeval) (err error)
    92  //sysnb	Gettimeofday(tv *Timeval) (err error)
    93  //sysnb	Time(t *Time_t) (tt Time_t, err error)
    94  //sys	Utime(path string, buf *Utimbuf) (err error)
    95  //sys	utimes(path string, times *[2]Timeval) (err error)
    96  
    97  // On x86 Linux, all the socket calls go through an extra indirection,
    98  // I think because the 5-register system call interface can't handle
    99  // the 6-argument calls like sendto and recvfrom. Instead the
   100  // arguments to the underlying system call are the number below
   101  // and a pointer to an array of uintptr. We hide the pointer in the
   102  // socketcall assembly to avoid allocation on every system call.
   103  
   104  const (
   105  	// see linux/net.h
   106  	_SOCKET      = 1
   107  	_BIND        = 2
   108  	_CONNECT     = 3
   109  	_LISTEN      = 4
   110  	_ACCEPT      = 5
   111  	_GETSOCKNAME = 6
   112  	_GETPEERNAME = 7
   113  	_SOCKETPAIR  = 8
   114  	_SEND        = 9
   115  	_RECV        = 10
   116  	_SENDTO      = 11
   117  	_RECVFROM    = 12
   118  	_SHUTDOWN    = 13
   119  	_SETSOCKOPT  = 14
   120  	_GETSOCKOPT  = 15
   121  	_SENDMSG     = 16
   122  	_RECVMSG     = 17
   123  	_ACCEPT4     = 18
   124  	_RECVMMSG    = 19
   125  	_SENDMMSG    = 20
   126  )
   127  
   128  // socketcall and rawsocketcall are accessed via assembly in x/sys/unix.
   129  //
   130  //go:linkname socketcall
   131  func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
   132  
   133  //go:linkname rawsocketcall
   134  func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
   135  
   136  func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
   137  	fd, e := socketcall(_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
   138  	if e != 0 {
   139  		err = e
   140  	}
   141  	return
   142  }
   143  
   144  func getsockname(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
   145  	_, e := rawsocketcall(_GETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
   146  	if e != 0 {
   147  		err = e
   148  	}
   149  	return
   150  }
   151  
   152  func getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
   153  	_, e := rawsocketcall(_GETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
   154  	if e != 0 {
   155  		err = e
   156  	}
   157  	return
   158  }
   159  
   160  func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
   161  	_, e := rawsocketcall(_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
   162  	if e != 0 {
   163  		err = e
   164  	}
   165  	return
   166  }
   167  
   168  func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
   169  	_, e := socketcall(_BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
   170  	if e != 0 {
   171  		err = e
   172  	}
   173  	return
   174  }
   175  
   176  func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
   177  	_, e := socketcall(_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
   178  	if e != 0 {
   179  		err = e
   180  	}
   181  	return
   182  }
   183  
   184  func socket(domain int, typ int, proto int) (fd int, err error) {
   185  	fd, e := rawsocketcall(_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0)
   186  	if e != 0 {
   187  		err = e
   188  	}
   189  	return
   190  }
   191  
   192  func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
   193  	_, e := socketcall(_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
   194  	if e != 0 {
   195  		err = e
   196  	}
   197  	return
   198  }
   199  
   200  func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
   201  	_, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0)
   202  	if e != 0 {
   203  		err = e
   204  	}
   205  	return
   206  }
   207  
   208  func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
   209  	var base uintptr
   210  	if len(p) > 0 {
   211  		base = uintptr(unsafe.Pointer(&p[0]))
   212  	}
   213  	n, e := socketcall(_RECVFROM, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
   214  	if e != 0 {
   215  		err = e
   216  	}
   217  	return
   218  }
   219  
   220  func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
   221  	var base uintptr
   222  	if len(p) > 0 {
   223  		base = uintptr(unsafe.Pointer(&p[0]))
   224  	}
   225  	_, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen))
   226  	if e != 0 {
   227  		err = e
   228  	}
   229  	return
   230  }
   231  
   232  func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
   233  	n, e := socketcall(_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
   234  	if e != 0 {
   235  		err = e
   236  	}
   237  	return
   238  }
   239  
   240  func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
   241  	n, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
   242  	if e != 0 {
   243  		err = e
   244  	}
   245  	return
   246  }
   247  
   248  func Listen(s int, n int) (err error) {
   249  	_, e := socketcall(_LISTEN, uintptr(s), uintptr(n), 0, 0, 0, 0)
   250  	if e != 0 {
   251  		err = e
   252  	}
   253  	return
   254  }
   255  
   256  func Shutdown(s, how int) (err error) {
   257  	_, e := socketcall(_SHUTDOWN, uintptr(s), uintptr(how), 0, 0, 0, 0)
   258  	if e != 0 {
   259  		err = e
   260  	}
   261  	return
   262  }
   263  
   264  func Fstatfs(fd int, buf *Statfs_t) (err error) {
   265  	_, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
   266  	if e != 0 {
   267  		err = e
   268  	}
   269  	return
   270  }
   271  
   272  func Statfs(path string, buf *Statfs_t) (err error) {
   273  	pathp, err := BytePtrFromString(path)
   274  	if err != nil {
   275  		return err
   276  	}
   277  	_, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
   278  	if e != 0 {
   279  		err = e
   280  	}
   281  	return
   282  }
   283  
   284  func (r *PtraceRegs) PC() uint64 { return uint64(uint32(r.Eip)) }
   285  
   286  func (r *PtraceRegs) SetPC(pc uint64) { r.Eip = int32(pc) }
   287  
   288  func (iov *Iovec) SetLen(length int) {
   289  	iov.Len = uint32(length)
   290  }
   291  
   292  func (msghdr *Msghdr) SetControllen(length int) {
   293  	msghdr.Controllen = uint32(length)
   294  }
   295  
   296  func (cmsg *Cmsghdr) SetLen(length int) {
   297  	cmsg.Len = uint32(length)
   298  }
   299
View as plain text