syscall_linux_386.mx raw
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 func seek(fd int, offset int64, whence int) (newoffset int64, err Errno)
78
79 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
80 newoffset, errno := seek(fd, offset, whence)
81 if errno != 0 {
82 return 0, errno
83 }
84 return newoffset, nil
85 }
86
87 //sys futimesat(dirfd int, path string, times *[2]Timeval) (err error)
88 //sysnb Gettimeofday(tv *Timeval) (err error)
89 //sysnb Time(t *Time_t) (tt Time_t, err error)
90 //sys Utime(path string, buf *Utimbuf) (err error)
91 //sys utimes(path string, times *[2]Timeval) (err error)
92
93 // On x86 Linux, all the socket calls go through an extra indirection,
94 // I think because the 5-register system call interface can't handle
95 // the 6-argument calls like sendto and recvfrom. Instead the
96 // arguments to the underlying system call are the number below
97 // and a pointer to an array of uintptr. We hide the pointer in the
98 // socketcall assembly to avoid allocation on every system call.
99
100 const (
101 // see linux/net.h
102 _SOCKET = 1
103 _BIND = 2
104 _CONNECT = 3
105 _LISTEN = 4
106 _ACCEPT = 5
107 _GETSOCKNAME = 6
108 _GETPEERNAME = 7
109 _SOCKETPAIR = 8
110 _SEND = 9
111 _RECV = 10
112 _SENDTO = 11
113 _RECVFROM = 12
114 _SHUTDOWN = 13
115 _SETSOCKOPT = 14
116 _GETSOCKOPT = 15
117 _SENDMSG = 16
118 _RECVMSG = 17
119 _ACCEPT4 = 18
120 _RECVMMSG = 19
121 _SENDMMSG = 20
122 )
123
124 func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
125 func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
126
127 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {
128 fd, e := socketcall(_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
129 if e != 0 {
130 err = e
131 }
132 return
133 }
134
135 func getsockname(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
136 _, e := rawsocketcall(_GETSOCKNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
137 if e != 0 {
138 err = e
139 }
140 return
141 }
142
143 func getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
144 _, e := rawsocketcall(_GETPEERNAME, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0)
145 if e != 0 {
146 err = e
147 }
148 return
149 }
150
151 func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
152 _, e := rawsocketcall(_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
153 if e != 0 {
154 err = e
155 }
156 return
157 }
158
159 func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
160 _, e := socketcall(_BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
161 if e != 0 {
162 err = e
163 }
164 return
165 }
166
167 func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
168 _, e := socketcall(_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
169 if e != 0 {
170 err = e
171 }
172 return
173 }
174
175 func socket(domain int, typ int, proto int) (fd int, err error) {
176 fd, e := rawsocketcall(_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0)
177 if e != 0 {
178 err = e
179 }
180 return
181 }
182
183 func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
184 _, e := socketcall(_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
185 if e != 0 {
186 err = e
187 }
188 return
189 }
190
191 func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
192 _, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0)
193 if e != 0 {
194 err = e
195 }
196 return
197 }
198
199 func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
200 var base uintptr
201 if len(p) > 0 {
202 base = uintptr(unsafe.Pointer(&p[0]))
203 }
204 n, e := socketcall(_RECVFROM, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
205 if e != 0 {
206 err = e
207 }
208 return
209 }
210
211 func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
212 var base uintptr
213 if len(p) > 0 {
214 base = uintptr(unsafe.Pointer(&p[0]))
215 }
216 _, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen))
217 if e != 0 {
218 err = e
219 }
220 return
221 }
222
223 func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
224 n, e := socketcall(_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
225 if e != 0 {
226 err = e
227 }
228 return
229 }
230
231 func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
232 n, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0)
233 if e != 0 {
234 err = e
235 }
236 return
237 }
238
239 func Listen(s int, n int) (err error) {
240 _, e := socketcall(_LISTEN, uintptr(s), uintptr(n), 0, 0, 0, 0)
241 if e != 0 {
242 err = e
243 }
244 return
245 }
246
247 func Shutdown(s, how int) (err error) {
248 _, e := socketcall(_SHUTDOWN, uintptr(s), uintptr(how), 0, 0, 0, 0)
249 if e != 0 {
250 err = e
251 }
252 return
253 }
254
255 func Fstatfs(fd int, buf *Statfs_t) (err error) {
256 _, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
257 if e != 0 {
258 err = e
259 }
260 return
261 }
262
263 func Statfs(path string, buf *Statfs_t) (err error) {
264 pathp, err := BytePtrFromString(path)
265 if err != nil {
266 return err
267 }
268 _, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
269 if e != 0 {
270 err = e
271 }
272 return
273 }
274
275 func (r *PtraceRegs) PC() uint64 { return uint64(uint32(r.Eip)) }
276
277 func (r *PtraceRegs) SetPC(pc uint64) { r.Eip = int32(pc) }
278
279 func (iov *Iovec) SetLen(length int) {
280 iov.Len = uint32(length)
281 }
282
283 func (msghdr *Msghdr) SetControllen(length int) {
284 msghdr.Controllen = uint32(length)
285 }
286
287 func (cmsg *Cmsghdr) SetLen(length int) {
288 cmsg.Len = uint32(length)
289 }
290