|
1 // Copyright 2018 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 aix |
|
6 |
|
7 // Aix system calls. |
|
8 // This file is compiled as ordinary Go code, |
|
9 // but it is also input to mksyscall, |
|
10 // which parses the //sys lines and generates system call stubs. |
|
11 // Note that sometimes we use a lowercase //sys name and |
|
12 // wrap it in our own nicer implementation. |
|
13 |
|
14 package unix |
|
15 |
|
16 import ( |
|
17 "syscall" |
|
18 "unsafe" |
|
19 ) |
|
20 |
|
21 /* |
|
22 * Wrapped |
|
23 */ |
|
24 |
|
25 //sys utimes(path string, times *[2]Timeval) (err error) |
|
26 func Utimes(path string, tv []Timeval) error { |
|
27 if len(tv) != 2 { |
|
28 return EINVAL |
|
29 } |
|
30 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) |
|
31 } |
|
32 |
|
33 //sys utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) |
|
34 func UtimesNano(path string, ts []Timespec) error { |
|
35 if len(ts) != 2 { |
|
36 return EINVAL |
|
37 } |
|
38 return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) |
|
39 } |
|
40 |
|
41 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { |
|
42 if ts == nil { |
|
43 return utimensat(dirfd, path, nil, flags) |
|
44 } |
|
45 if len(ts) != 2 { |
|
46 return EINVAL |
|
47 } |
|
48 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) |
|
49 } |
|
50 |
|
51 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { |
|
52 if sa.Port < 0 || sa.Port > 0xFFFF { |
|
53 return nil, 0, EINVAL |
|
54 } |
|
55 sa.raw.Family = AF_INET |
|
56 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) |
|
57 p[0] = byte(sa.Port >> 8) |
|
58 p[1] = byte(sa.Port) |
|
59 for i := 0; i < len(sa.Addr); i++ { |
|
60 sa.raw.Addr[i] = sa.Addr[i] |
|
61 } |
|
62 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil |
|
63 } |
|
64 |
|
65 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { |
|
66 if sa.Port < 0 || sa.Port > 0xFFFF { |
|
67 return nil, 0, EINVAL |
|
68 } |
|
69 sa.raw.Family = AF_INET6 |
|
70 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) |
|
71 p[0] = byte(sa.Port >> 8) |
|
72 p[1] = byte(sa.Port) |
|
73 sa.raw.Scope_id = sa.ZoneId |
|
74 for i := 0; i < len(sa.Addr); i++ { |
|
75 sa.raw.Addr[i] = sa.Addr[i] |
|
76 } |
|
77 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil |
|
78 } |
|
79 |
|
80 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { |
|
81 name := sa.Name |
|
82 n := len(name) |
|
83 if n > len(sa.raw.Path) { |
|
84 return nil, 0, EINVAL |
|
85 } |
|
86 if n == len(sa.raw.Path) && name[0] != '@' { |
|
87 return nil, 0, EINVAL |
|
88 } |
|
89 sa.raw.Family = AF_UNIX |
|
90 for i := 0; i < n; i++ { |
|
91 sa.raw.Path[i] = uint8(name[i]) |
|
92 } |
|
93 // length is family (uint16), name, NUL. |
|
94 sl := _Socklen(2) |
|
95 if n > 0 { |
|
96 sl += _Socklen(n) + 1 |
|
97 } |
|
98 if sa.raw.Path[0] == '@' { |
|
99 sa.raw.Path[0] = 0 |
|
100 // Don't count trailing NUL for abstract address. |
|
101 sl-- |
|
102 } |
|
103 |
|
104 return unsafe.Pointer(&sa.raw), sl, nil |
|
105 } |
|
106 |
|
107 func Getsockname(fd int) (sa Sockaddr, err error) { |
|
108 var rsa RawSockaddrAny |
|
109 var len _Socklen = SizeofSockaddrAny |
|
110 if err = getsockname(fd, &rsa, &len); err != nil { |
|
111 return |
|
112 } |
|
113 return anyToSockaddr(fd, &rsa) |
|
114 } |
|
115 |
|
116 //sys getcwd(buf []byte) (err error) |
|
117 |
|
118 const ImplementsGetwd = true |
|
119 |
|
120 func Getwd() (ret string, err error) { |
|
121 for len := uint64(4096); ; len *= 2 { |
|
122 b := make([]byte, len) |
|
123 err := getcwd(b) |
|
124 if err == nil { |
|
125 i := 0 |
|
126 for b[i] != 0 { |
|
127 i++ |
|
128 } |
|
129 return string(b[0:i]), nil |
|
130 } |
|
131 if err != ERANGE { |
|
132 return "", err |
|
133 } |
|
134 } |
|
135 } |
|
136 |
|
137 func Getcwd(buf []byte) (n int, err error) { |
|
138 err = getcwd(buf) |
|
139 if err == nil { |
|
140 i := 0 |
|
141 for buf[i] != 0 { |
|
142 i++ |
|
143 } |
|
144 n = i + 1 |
|
145 } |
|
146 return |
|
147 } |
|
148 |
|
149 func Getgroups() (gids []int, err error) { |
|
150 n, err := getgroups(0, nil) |
|
151 if err != nil { |
|
152 return nil, err |
|
153 } |
|
154 if n == 0 { |
|
155 return nil, nil |
|
156 } |
|
157 |
|
158 // Sanity check group count. Max is 16 on BSD. |
|
159 if n < 0 || n > 1000 { |
|
160 return nil, EINVAL |
|
161 } |
|
162 |
|
163 a := make([]_Gid_t, n) |
|
164 n, err = getgroups(n, &a[0]) |
|
165 if err != nil { |
|
166 return nil, err |
|
167 } |
|
168 gids = make([]int, n) |
|
169 for i, v := range a[0:n] { |
|
170 gids[i] = int(v) |
|
171 } |
|
172 return |
|
173 } |
|
174 |
|
175 func Setgroups(gids []int) (err error) { |
|
176 if len(gids) == 0 { |
|
177 return setgroups(0, nil) |
|
178 } |
|
179 |
|
180 a := make([]_Gid_t, len(gids)) |
|
181 for i, v := range gids { |
|
182 a[i] = _Gid_t(v) |
|
183 } |
|
184 return setgroups(len(a), &a[0]) |
|
185 } |
|
186 |
|
187 /* |
|
188 * Socket |
|
189 */ |
|
190 |
|
191 //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) |
|
192 |
|
193 func Accept(fd int) (nfd int, sa Sockaddr, err error) { |
|
194 var rsa RawSockaddrAny |
|
195 var len _Socklen = SizeofSockaddrAny |
|
196 nfd, err = accept(fd, &rsa, &len) |
|
197 if nfd == -1 { |
|
198 return |
|
199 } |
|
200 sa, err = anyToSockaddr(fd, &rsa) |
|
201 if err != nil { |
|
202 Close(nfd) |
|
203 nfd = 0 |
|
204 } |
|
205 return |
|
206 } |
|
207 |
|
208 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { |
|
209 // Recvmsg not implemented on AIX |
|
210 sa := new(SockaddrUnix) |
|
211 return -1, -1, -1, sa, ENOSYS |
|
212 } |
|
213 |
|
214 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { |
|
215 _, err = SendmsgN(fd, p, oob, to, flags) |
|
216 return |
|
217 } |
|
218 |
|
219 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { |
|
220 // SendmsgN not implemented on AIX |
|
221 return -1, ENOSYS |
|
222 } |
|
223 |
|
224 func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { |
|
225 switch rsa.Addr.Family { |
|
226 |
|
227 case AF_UNIX: |
|
228 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) |
|
229 sa := new(SockaddrUnix) |
|
230 |
|
231 // Some versions of AIX have a bug in getsockname (see IV78655). |
|
232 // We can't rely on sa.Len being set correctly. |
|
233 n := SizeofSockaddrUnix - 3 // substract leading Family, Len, terminating NUL. |
|
234 for i := 0; i < n; i++ { |
|
235 if pp.Path[i] == 0 { |
|
236 n = i |
|
237 break |
|
238 } |
|
239 } |
|
240 |
|
241 bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] |
|
242 sa.Name = string(bytes) |
|
243 return sa, nil |
|
244 |
|
245 case AF_INET: |
|
246 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) |
|
247 sa := new(SockaddrInet4) |
|
248 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) |
|
249 sa.Port = int(p[0])<<8 + int(p[1]) |
|
250 for i := 0; i < len(sa.Addr); i++ { |
|
251 sa.Addr[i] = pp.Addr[i] |
|
252 } |
|
253 return sa, nil |
|
254 |
|
255 case AF_INET6: |
|
256 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) |
|
257 sa := new(SockaddrInet6) |
|
258 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) |
|
259 sa.Port = int(p[0])<<8 + int(p[1]) |
|
260 sa.ZoneId = pp.Scope_id |
|
261 for i := 0; i < len(sa.Addr); i++ { |
|
262 sa.Addr[i] = pp.Addr[i] |
|
263 } |
|
264 return sa, nil |
|
265 } |
|
266 return nil, EAFNOSUPPORT |
|
267 } |
|
268 |
|
269 func Gettimeofday(tv *Timeval) (err error) { |
|
270 err = gettimeofday(tv, nil) |
|
271 return |
|
272 } |
|
273 |
|
274 // TODO |
|
275 func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { |
|
276 return -1, ENOSYS |
|
277 } |
|
278 |
|
279 //sys getdirent(fd int, buf []byte) (n int, err error) |
|
280 func ReadDirent(fd int, buf []byte) (n int, err error) { |
|
281 return getdirent(fd, buf) |
|
282 } |
|
283 |
|
284 //sys wait4(pid Pid_t, status *_C_int, options int, rusage *Rusage) (wpid Pid_t, err error) |
|
285 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { |
|
286 var status _C_int |
|
287 var r Pid_t |
|
288 err = ERESTART |
|
289 // AIX wait4 may return with ERESTART errno, while the processus is still |
|
290 // active. |
|
291 for err == ERESTART { |
|
292 r, err = wait4(Pid_t(pid), &status, options, rusage) |
|
293 } |
|
294 wpid = int(r) |
|
295 if wstatus != nil { |
|
296 *wstatus = WaitStatus(status) |
|
297 } |
|
298 return |
|
299 } |
|
300 |
|
301 /* |
|
302 * Wait |
|
303 */ |
|
304 |
|
305 type WaitStatus uint32 |
|
306 |
|
307 func (w WaitStatus) Stopped() bool { return w&0x40 != 0 } |
|
308 func (w WaitStatus) StopSignal() syscall.Signal { |
|
309 if !w.Stopped() { |
|
310 return -1 |
|
311 } |
|
312 return syscall.Signal(w>>8) & 0xFF |
|
313 } |
|
314 |
|
315 func (w WaitStatus) Exited() bool { return w&0xFF == 0 } |
|
316 func (w WaitStatus) ExitStatus() int { |
|
317 if !w.Exited() { |
|
318 return -1 |
|
319 } |
|
320 return int((w >> 8) & 0xFF) |
|
321 } |
|
322 |
|
323 func (w WaitStatus) Signaled() bool { return w&0x40 == 0 && w&0xFF != 0 } |
|
324 func (w WaitStatus) Signal() syscall.Signal { |
|
325 if !w.Signaled() { |
|
326 return -1 |
|
327 } |
|
328 return syscall.Signal(w>>16) & 0xFF |
|
329 } |
|
330 |
|
331 func (w WaitStatus) Continued() bool { return w&0x01000000 != 0 } |
|
332 |
|
333 func (w WaitStatus) CoreDump() bool { return w&0x200 != 0 } |
|
334 |
|
335 func (w WaitStatus) TrapCause() int { return -1 } |
|
336 |
|
337 //sys ioctl(fd int, req uint, arg uintptr) (err error) |
|
338 |
|
339 // ioctl itself should not be exposed directly, but additional get/set |
|
340 // functions for specific types are permissible. |
|
341 |
|
342 // IoctlSetInt performs an ioctl operation which sets an integer value |
|
343 // on fd, using the specified request number. |
|
344 func IoctlSetInt(fd int, req uint, value int) error { |
|
345 return ioctl(fd, req, uintptr(value)) |
|
346 } |
|
347 |
|
348 func ioctlSetWinsize(fd int, req uint, value *Winsize) error { |
|
349 return ioctl(fd, req, uintptr(unsafe.Pointer(value))) |
|
350 } |
|
351 |
|
352 func ioctlSetTermios(fd int, req uint, value *Termios) error { |
|
353 return ioctl(fd, req, uintptr(unsafe.Pointer(value))) |
|
354 } |
|
355 |
|
356 // IoctlGetInt performs an ioctl operation which gets an integer value |
|
357 // from fd, using the specified request number. |
|
358 func IoctlGetInt(fd int, req uint) (int, error) { |
|
359 var value int |
|
360 err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) |
|
361 return value, err |
|
362 } |
|
363 |
|
364 func IoctlGetWinsize(fd int, req uint) (*Winsize, error) { |
|
365 var value Winsize |
|
366 err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) |
|
367 return &value, err |
|
368 } |
|
369 |
|
370 func IoctlGetTermios(fd int, req uint) (*Termios, error) { |
|
371 var value Termios |
|
372 err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) |
|
373 return &value, err |
|
374 } |
|
375 |
|
376 // fcntl must never be called with cmd=F_DUP2FD because it doesn't work on AIX |
|
377 // There is no way to create a custom fcntl and to keep //sys fcntl easily, |
|
378 // Therefore, the programmer must call dup2 instead of fcntl in this case. |
|
379 |
|
380 // FcntlInt performs a fcntl syscall on fd with the provided command and argument. |
|
381 //sys FcntlInt(fd uintptr, cmd int, arg int) (r int,err error) = fcntl |
|
382 |
|
383 // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. |
|
384 //sys FcntlFlock(fd uintptr, cmd int, lk *Flock_t) (err error) = fcntl |
|
385 |
|
386 func Flock(fd int, how int) (err error) { |
|
387 return syscall.Flock(fd, how) |
|
388 } |
|
389 |
|
390 /* |
|
391 * Direct access |
|
392 */ |
|
393 |
|
394 //sys Acct(path string) (err error) |
|
395 //sys Chdir(path string) (err error) |
|
396 //sys Chroot(path string) (err error) |
|
397 //sys Close(fd int) (err error) |
|
398 //sys Dup(oldfd int) (fd int, err error) |
|
399 //sys Dup3(oldfd int, newfd int, flags int) (err error) |
|
400 //sys Exit(code int) |
|
401 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) |
|
402 //sys Fallocate(fd int, mode uint32, off int64, len int64) (err error) |
|
403 //sys Fchdir(fd int) (err error) |
|
404 //sys Fchmod(fd int, mode uint32) (err error) |
|
405 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) |
|
406 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) |
|
407 //sys fcntl(fd int, cmd int, arg int) (val int, err error) |
|
408 //sys Fdatasync(fd int) (err error) |
|
409 //sys Fsync(fd int) (err error) |
|
410 // readdir_r |
|
411 //sysnb Getpgid(pid int) (pgid int, err error) |
|
412 |
|
413 //sys Getpgrp() (pid int) |
|
414 |
|
415 //sysnb Getpid() (pid int) |
|
416 //sysnb Getppid() (ppid int) |
|
417 //sys Getpriority(which int, who int) (prio int, err error) |
|
418 //sysnb Getrusage(who int, rusage *Rusage) (err error) |
|
419 //sysnb Getsid(pid int) (sid int, err error) |
|
420 //sysnb Kill(pid int, sig syscall.Signal) (err error) |
|
421 //sys Klogctl(typ int, buf []byte) (n int, err error) = syslog |
|
422 //sys Mkdir(dirfd int, path string, mode uint32) (err error) |
|
423 //sys Mkdirat(dirfd int, path string, mode uint32) (err error) |
|
424 //sys Mkfifo(path string, mode uint32) (err error) |
|
425 //sys Mknod(path string, mode uint32, dev int) (err error) |
|
426 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) |
|
427 //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) |
|
428 //sys Open(path string, mode int, perm uint32) (fd int, err error) = open64 |
|
429 //sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) |
|
430 //sys read(fd int, p []byte) (n int, err error) |
|
431 //sys Readlink(path string, buf []byte) (n int, err error) |
|
432 //sys Removexattr(path string, attr string) (err error) |
|
433 //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) |
|
434 //sys Setdomainname(p []byte) (err error) |
|
435 //sys Sethostname(p []byte) (err error) |
|
436 //sysnb Setpgid(pid int, pgid int) (err error) |
|
437 //sysnb Setsid() (pid int, err error) |
|
438 //sysnb Settimeofday(tv *Timeval) (err error) |
|
439 |
|
440 //sys Setuid(uid int) (err error) |
|
441 //sys Setgid(uid int) (err error) |
|
442 |
|
443 //sys Setpriority(which int, who int, prio int) (err error) |
|
444 //sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) |
|
445 //sys Sync() |
|
446 //sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error) |
|
447 //sysnb Times(tms *Tms) (ticks uintptr, err error) |
|
448 //sysnb Umask(mask int) (oldmask int) |
|
449 //sysnb Uname(buf *Utsname) (err error) |
|
450 //TODO umount |
|
451 // //sys Unmount(target string, flags int) (err error) = umount |
|
452 //sys Unlink(path string) (err error) |
|
453 //sys Unlinkat(dirfd int, path string, flags int) (err error) |
|
454 //sys Unshare(flags int) (err error) |
|
455 //sys Ustat(dev int, ubuf *Ustat_t) (err error) |
|
456 //sys write(fd int, p []byte) (n int, err error) |
|
457 //sys readlen(fd int, p *byte, np int) (n int, err error) = read |
|
458 //sys writelen(fd int, p *byte, np int) (n int, err error) = write |
|
459 |
|
460 //sys Dup2(oldfd int, newfd int) (err error) |
|
461 //sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = posix_fadvise64 |
|
462 //sys Fchown(fd int, uid int, gid int) (err error) |
|
463 //sys Fstat(fd int, stat *Stat_t) (err error) |
|
464 //sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = fstatat |
|
465 //sys Fstatfs(fd int, buf *Statfs_t) (err error) |
|
466 //sys Ftruncate(fd int, length int64) (err error) |
|
467 //sysnb Getegid() (egid int) |
|
468 //sysnb Geteuid() (euid int) |
|
469 //sysnb Getgid() (gid int) |
|
470 //sysnb Getuid() (uid int) |
|
471 //sys Lchown(path string, uid int, gid int) (err error) |
|
472 //sys Listen(s int, n int) (err error) |
|
473 //sys Lstat(path string, stat *Stat_t) (err error) |
|
474 //sys Pause() (err error) |
|
475 //sys Pread(fd int, p []byte, offset int64) (n int, err error) = pread64 |
|
476 //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) = pwrite64 |
|
477 //TODO Select |
|
478 // //sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) |
|
479 //sys Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) |
|
480 //sysnb Setregid(rgid int, egid int) (err error) |
|
481 //sysnb Setreuid(ruid int, euid int) (err error) |
|
482 //sys Shutdown(fd int, how int) (err error) |
|
483 //sys Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) |
|
484 //sys Stat(path string, stat *Stat_t) (err error) |
|
485 //sys Statfs(path string, buf *Statfs_t) (err error) |
|
486 //sys Truncate(path string, length int64) (err error) |
|
487 |
|
488 //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) |
|
489 //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) |
|
490 //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) |
|
491 //sysnb setgroups(n int, list *_Gid_t) (err error) |
|
492 //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) |
|
493 //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) |
|
494 //sysnb socket(domain int, typ int, proto int) (fd int, err error) |
|
495 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) |
|
496 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) |
|
497 //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) |
|
498 //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) |
|
499 //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) |
|
500 //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) |
|
501 //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) |
|
502 |
|
503 //sys munmap(addr uintptr, length uintptr) (err error) |
|
504 |
|
505 var mapper = &mmapper{ |
|
506 active: make(map[*byte][]byte), |
|
507 mmap: mmap, |
|
508 munmap: munmap, |
|
509 } |
|
510 |
|
511 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { |
|
512 return mapper.Mmap(fd, offset, length, prot, flags) |
|
513 } |
|
514 |
|
515 func Munmap(b []byte) (err error) { |
|
516 return mapper.Munmap(b) |
|
517 } |
|
518 |
|
519 //sys Madvise(b []byte, advice int) (err error) |
|
520 //sys Mprotect(b []byte, prot int) (err error) |
|
521 //sys Mlock(b []byte) (err error) |
|
522 //sys Mlockall(flags int) (err error) |
|
523 //sys Msync(b []byte, flags int) (err error) |
|
524 //sys Munlock(b []byte) (err error) |
|
525 //sys Munlockall() (err error) |
|
526 |
|
527 //sysnb pipe(p *[2]_C_int) (err error) |
|
528 |
|
529 func Pipe(p []int) (err error) { |
|
530 if len(p) != 2 { |
|
531 return EINVAL |
|
532 } |
|
533 var pp [2]_C_int |
|
534 err = pipe(&pp) |
|
535 p[0] = int(pp[0]) |
|
536 p[1] = int(pp[1]) |
|
537 return |
|
538 } |
|
539 |
|
540 //sysnb pipe2(p *[2]_C_int, flags int) (err error) |
|
541 |
|
542 func Pipe2(p []int, flags int) (err error) { |
|
543 if len(p) != 2 { |
|
544 return EINVAL |
|
545 } |
|
546 var pp [2]_C_int |
|
547 err = pipe2(&pp, flags) |
|
548 p[0] = int(pp[0]) |
|
549 p[1] = int(pp[1]) |
|
550 return |
|
551 } |
|
552 |
|
553 //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) |
|
554 |
|
555 func Poll(fds []PollFd, timeout int) (n int, err error) { |
|
556 if len(fds) == 0 { |
|
557 return poll(nil, 0, timeout) |
|
558 } |
|
559 return poll(&fds[0], len(fds), timeout) |
|
560 } |
|
561 |
|
562 //sys gettimeofday(tv *Timeval, tzp *Timezone) (err error) |
|
563 //sysnb Time(t *Time_t) (tt Time_t, err error) |
|
564 //sys Utime(path string, buf *Utimbuf) (err error) |