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 }