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