]>
Commit | Line | Data |
---|---|---|
15c0b25d AP |
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 darwin dragonfly freebsd netbsd openbsd | |
6 | ||
7 | // BSD system call wrappers shared by *BSD based systems | |
8 | // including OS X (Darwin) and FreeBSD. Like the other | |
9 | // syscall_*.go files it is compiled as Go code but also | |
10 | // used as input to mksyscall which parses the //sys | |
11 | // lines and generates system call stubs. | |
12 | ||
13 | package unix | |
14 | ||
15 | import ( | |
16 | "runtime" | |
17 | "syscall" | |
18 | "unsafe" | |
19 | ) | |
20 | ||
21 | /* | |
22 | * Wrapped | |
23 | */ | |
24 | ||
25 | //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) | |
26 | //sysnb setgroups(ngid int, gid *_Gid_t) (err error) | |
27 | ||
28 | func Getgroups() (gids []int, err error) { | |
29 | n, err := getgroups(0, nil) | |
30 | if err != nil { | |
31 | return nil, err | |
32 | } | |
33 | if n == 0 { | |
34 | return nil, nil | |
35 | } | |
36 | ||
37 | // Sanity check group count. Max is 16 on BSD. | |
38 | if n < 0 || n > 1000 { | |
39 | return nil, EINVAL | |
40 | } | |
41 | ||
42 | a := make([]_Gid_t, n) | |
43 | n, err = getgroups(n, &a[0]) | |
44 | if err != nil { | |
45 | return nil, err | |
46 | } | |
47 | gids = make([]int, n) | |
48 | for i, v := range a[0:n] { | |
49 | gids[i] = int(v) | |
50 | } | |
51 | return | |
52 | } | |
53 | ||
54 | func Setgroups(gids []int) (err error) { | |
55 | if len(gids) == 0 { | |
56 | return setgroups(0, nil) | |
57 | } | |
58 | ||
59 | a := make([]_Gid_t, len(gids)) | |
60 | for i, v := range gids { | |
61 | a[i] = _Gid_t(v) | |
62 | } | |
63 | return setgroups(len(a), &a[0]) | |
64 | } | |
65 | ||
66 | func ReadDirent(fd int, buf []byte) (n int, err error) { | |
67 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. | |
68 | // 64 bits should be enough. (32 bits isn't even on 386). Since the | |
69 | // actual system call is getdirentries64, 64 is a good guess. | |
70 | // TODO(rsc): Can we use a single global basep for all calls? | |
71 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) | |
72 | return Getdirentries(fd, buf, base) | |
73 | } | |
74 | ||
75 | // Wait status is 7 bits at bottom, either 0 (exited), | |
76 | // 0x7F (stopped), or a signal number that caused an exit. | |
77 | // The 0x80 bit is whether there was a core dump. | |
78 | // An extra number (exit code, signal causing a stop) | |
79 | // is in the high bits. | |
80 | ||
81 | type WaitStatus uint32 | |
82 | ||
83 | const ( | |
84 | mask = 0x7F | |
85 | core = 0x80 | |
86 | shift = 8 | |
87 | ||
88 | exited = 0 | |
89 | stopped = 0x7F | |
90 | ) | |
91 | ||
92 | func (w WaitStatus) Exited() bool { return w&mask == exited } | |
93 | ||
94 | func (w WaitStatus) ExitStatus() int { | |
95 | if w&mask != exited { | |
96 | return -1 | |
97 | } | |
98 | return int(w >> shift) | |
99 | } | |
100 | ||
101 | func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } | |
102 | ||
103 | func (w WaitStatus) Signal() syscall.Signal { | |
104 | sig := syscall.Signal(w & mask) | |
105 | if sig == stopped || sig == 0 { | |
106 | return -1 | |
107 | } | |
108 | return sig | |
109 | } | |
110 | ||
111 | func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } | |
112 | ||
113 | func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP } | |
114 | ||
115 | func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP } | |
116 | ||
117 | func (w WaitStatus) StopSignal() syscall.Signal { | |
118 | if !w.Stopped() { | |
119 | return -1 | |
120 | } | |
121 | return syscall.Signal(w>>shift) & 0xFF | |
122 | } | |
123 | ||
124 | func (w WaitStatus) TrapCause() int { return -1 } | |
125 | ||
126 | //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) | |
127 | ||
128 | func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { | |
129 | var status _C_int | |
130 | wpid, err = wait4(pid, &status, options, rusage) | |
131 | if wstatus != nil { | |
132 | *wstatus = WaitStatus(status) | |
133 | } | |
134 | return | |
135 | } | |
136 | ||
137 | //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) | |
138 | //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | |
139 | //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) | |
140 | //sysnb socket(domain int, typ int, proto int) (fd int, err error) | |
141 | //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) | |
142 | //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) | |
143 | //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | |
144 | //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) | |
145 | //sys Shutdown(s int, how int) (err error) | |
146 | ||
147 | func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { | |
148 | if sa.Port < 0 || sa.Port > 0xFFFF { | |
149 | return nil, 0, EINVAL | |
150 | } | |
151 | sa.raw.Len = SizeofSockaddrInet4 | |
152 | sa.raw.Family = AF_INET | |
153 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | |
154 | p[0] = byte(sa.Port >> 8) | |
155 | p[1] = byte(sa.Port) | |
156 | for i := 0; i < len(sa.Addr); i++ { | |
157 | sa.raw.Addr[i] = sa.Addr[i] | |
158 | } | |
159 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | |
160 | } | |
161 | ||
162 | func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { | |
163 | if sa.Port < 0 || sa.Port > 0xFFFF { | |
164 | return nil, 0, EINVAL | |
165 | } | |
166 | sa.raw.Len = SizeofSockaddrInet6 | |
167 | sa.raw.Family = AF_INET6 | |
168 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | |
169 | p[0] = byte(sa.Port >> 8) | |
170 | p[1] = byte(sa.Port) | |
171 | sa.raw.Scope_id = sa.ZoneId | |
172 | for i := 0; i < len(sa.Addr); i++ { | |
173 | sa.raw.Addr[i] = sa.Addr[i] | |
174 | } | |
175 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | |
176 | } | |
177 | ||
178 | func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { | |
179 | name := sa.Name | |
180 | n := len(name) | |
181 | if n >= len(sa.raw.Path) || n == 0 { | |
182 | return nil, 0, EINVAL | |
183 | } | |
184 | sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL | |
185 | sa.raw.Family = AF_UNIX | |
186 | for i := 0; i < n; i++ { | |
187 | sa.raw.Path[i] = int8(name[i]) | |
188 | } | |
189 | return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil | |
190 | } | |
191 | ||
192 | func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { | |
193 | if sa.Index == 0 { | |
194 | return nil, 0, EINVAL | |
195 | } | |
196 | sa.raw.Len = sa.Len | |
197 | sa.raw.Family = AF_LINK | |
198 | sa.raw.Index = sa.Index | |
199 | sa.raw.Type = sa.Type | |
200 | sa.raw.Nlen = sa.Nlen | |
201 | sa.raw.Alen = sa.Alen | |
202 | sa.raw.Slen = sa.Slen | |
203 | for i := 0; i < len(sa.raw.Data); i++ { | |
204 | sa.raw.Data[i] = sa.Data[i] | |
205 | } | |
206 | return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil | |
207 | } | |
208 | ||
209 | func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { | |
210 | switch rsa.Addr.Family { | |
211 | case AF_LINK: | |
212 | pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa)) | |
213 | sa := new(SockaddrDatalink) | |
214 | sa.Len = pp.Len | |
215 | sa.Family = pp.Family | |
216 | sa.Index = pp.Index | |
217 | sa.Type = pp.Type | |
218 | sa.Nlen = pp.Nlen | |
219 | sa.Alen = pp.Alen | |
220 | sa.Slen = pp.Slen | |
221 | for i := 0; i < len(sa.Data); i++ { | |
222 | sa.Data[i] = pp.Data[i] | |
223 | } | |
224 | return sa, nil | |
225 | ||
226 | case AF_UNIX: | |
227 | pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) | |
228 | if pp.Len < 2 || pp.Len > SizeofSockaddrUnix { | |
229 | return nil, EINVAL | |
230 | } | |
231 | sa := new(SockaddrUnix) | |
232 | ||
233 | // Some BSDs include the trailing NUL in the length, whereas | |
234 | // others do not. Work around this by subtracting the leading | |
235 | // family and len. The path is then scanned to see if a NUL | |
236 | // terminator still exists within the length. | |
237 | n := int(pp.Len) - 2 // subtract leading Family, Len | |
238 | for i := 0; i < n; i++ { | |
239 | if pp.Path[i] == 0 { | |
240 | // found early NUL; assume Len included the NUL | |
241 | // or was overestimating. | |
242 | n = i | |
243 | break | |
244 | } | |
245 | } | |
246 | bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] | |
247 | sa.Name = string(bytes) | |
248 | return sa, nil | |
249 | ||
250 | case AF_INET: | |
251 | pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) | |
252 | sa := new(SockaddrInet4) | |
253 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | |
254 | sa.Port = int(p[0])<<8 + int(p[1]) | |
255 | for i := 0; i < len(sa.Addr); i++ { | |
256 | sa.Addr[i] = pp.Addr[i] | |
257 | } | |
258 | return sa, nil | |
259 | ||
260 | case AF_INET6: | |
261 | pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) | |
262 | sa := new(SockaddrInet6) | |
263 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | |
264 | sa.Port = int(p[0])<<8 + int(p[1]) | |
265 | sa.ZoneId = pp.Scope_id | |
266 | for i := 0; i < len(sa.Addr); i++ { | |
267 | sa.Addr[i] = pp.Addr[i] | |
268 | } | |
269 | return sa, nil | |
270 | } | |
271 | return nil, EAFNOSUPPORT | |
272 | } | |
273 | ||
274 | func Accept(fd int) (nfd int, sa Sockaddr, err error) { | |
275 | var rsa RawSockaddrAny | |
276 | var len _Socklen = SizeofSockaddrAny | |
277 | nfd, err = accept(fd, &rsa, &len) | |
278 | if err != nil { | |
279 | return | |
280 | } | |
281 | if runtime.GOOS == "darwin" && len == 0 { | |
282 | // Accepted socket has no address. | |
283 | // This is likely due to a bug in xnu kernels, | |
284 | // where instead of ECONNABORTED error socket | |
285 | // is accepted, but has no address. | |
286 | Close(nfd) | |
287 | return 0, nil, ECONNABORTED | |
288 | } | |
289 | sa, err = anyToSockaddr(fd, &rsa) | |
290 | if err != nil { | |
291 | Close(nfd) | |
292 | nfd = 0 | |
293 | } | |
294 | return | |
295 | } | |
296 | ||
297 | func Getsockname(fd int) (sa Sockaddr, err error) { | |
298 | var rsa RawSockaddrAny | |
299 | var len _Socklen = SizeofSockaddrAny | |
300 | if err = getsockname(fd, &rsa, &len); err != nil { | |
301 | return | |
302 | } | |
303 | // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be | |
304 | // reported upstream. | |
305 | if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { | |
306 | rsa.Addr.Family = AF_UNIX | |
307 | rsa.Addr.Len = SizeofSockaddrUnix | |
308 | } | |
309 | return anyToSockaddr(fd, &rsa) | |
310 | } | |
311 | ||
312 | //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) | |
313 | ||
314 | // GetsockoptString returns the string value of the socket option opt for the | |
315 | // socket associated with fd at the given socket level. | |
316 | func GetsockoptString(fd, level, opt int) (string, error) { | |
317 | buf := make([]byte, 256) | |
318 | vallen := _Socklen(len(buf)) | |
319 | err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) | |
320 | if err != nil { | |
321 | return "", err | |
322 | } | |
323 | return string(buf[:vallen-1]), nil | |
324 | } | |
325 | ||
326 | //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) | |
327 | //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) | |
328 | //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) | |
329 | ||
330 | func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { | |
331 | var msg Msghdr | |
332 | var rsa RawSockaddrAny | |
333 | msg.Name = (*byte)(unsafe.Pointer(&rsa)) | |
334 | msg.Namelen = uint32(SizeofSockaddrAny) | |
335 | var iov Iovec | |
336 | if len(p) > 0 { | |
337 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | |
338 | iov.SetLen(len(p)) | |
339 | } | |
340 | var dummy byte | |
341 | if len(oob) > 0 { | |
342 | // receive at least one normal byte | |
343 | if len(p) == 0 { | |
344 | iov.Base = &dummy | |
345 | iov.SetLen(1) | |
346 | } | |
347 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | |
348 | msg.SetControllen(len(oob)) | |
349 | } | |
350 | msg.Iov = &iov | |
351 | msg.Iovlen = 1 | |
352 | if n, err = recvmsg(fd, &msg, flags); err != nil { | |
353 | return | |
354 | } | |
355 | oobn = int(msg.Controllen) | |
356 | recvflags = int(msg.Flags) | |
357 | // source address is only specified if the socket is unconnected | |
358 | if rsa.Addr.Family != AF_UNSPEC { | |
359 | from, err = anyToSockaddr(fd, &rsa) | |
360 | } | |
361 | return | |
362 | } | |
363 | ||
364 | //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) | |
365 | ||
366 | func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { | |
367 | _, err = SendmsgN(fd, p, oob, to, flags) | |
368 | return | |
369 | } | |
370 | ||
371 | func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { | |
372 | var ptr unsafe.Pointer | |
373 | var salen _Socklen | |
374 | if to != nil { | |
375 | ptr, salen, err = to.sockaddr() | |
376 | if err != nil { | |
377 | return 0, err | |
378 | } | |
379 | } | |
380 | var msg Msghdr | |
381 | msg.Name = (*byte)(unsafe.Pointer(ptr)) | |
382 | msg.Namelen = uint32(salen) | |
383 | var iov Iovec | |
384 | if len(p) > 0 { | |
385 | iov.Base = (*byte)(unsafe.Pointer(&p[0])) | |
386 | iov.SetLen(len(p)) | |
387 | } | |
388 | var dummy byte | |
389 | if len(oob) > 0 { | |
390 | // send at least one normal byte | |
391 | if len(p) == 0 { | |
392 | iov.Base = &dummy | |
393 | iov.SetLen(1) | |
394 | } | |
395 | msg.Control = (*byte)(unsafe.Pointer(&oob[0])) | |
396 | msg.SetControllen(len(oob)) | |
397 | } | |
398 | msg.Iov = &iov | |
399 | msg.Iovlen = 1 | |
400 | if n, err = sendmsg(fd, &msg, flags); err != nil { | |
401 | return 0, err | |
402 | } | |
403 | if len(oob) > 0 && len(p) == 0 { | |
404 | n = 0 | |
405 | } | |
406 | return n, nil | |
407 | } | |
408 | ||
409 | //sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) | |
410 | ||
411 | func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { | |
412 | var change, event unsafe.Pointer | |
413 | if len(changes) > 0 { | |
414 | change = unsafe.Pointer(&changes[0]) | |
415 | } | |
416 | if len(events) > 0 { | |
417 | event = unsafe.Pointer(&events[0]) | |
418 | } | |
419 | return kevent(kq, change, len(changes), event, len(events), timeout) | |
420 | } | |
421 | ||
422 | //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL | |
423 | ||
424 | // sysctlmib translates name to mib number and appends any additional args. | |
425 | func sysctlmib(name string, args ...int) ([]_C_int, error) { | |
426 | // Translate name to mib number. | |
427 | mib, err := nametomib(name) | |
428 | if err != nil { | |
429 | return nil, err | |
430 | } | |
431 | ||
432 | for _, a := range args { | |
433 | mib = append(mib, _C_int(a)) | |
434 | } | |
435 | ||
436 | return mib, nil | |
437 | } | |
438 | ||
439 | func Sysctl(name string) (string, error) { | |
440 | return SysctlArgs(name) | |
441 | } | |
442 | ||
443 | func SysctlArgs(name string, args ...int) (string, error) { | |
444 | buf, err := SysctlRaw(name, args...) | |
445 | if err != nil { | |
446 | return "", err | |
447 | } | |
448 | n := len(buf) | |
449 | ||
450 | // Throw away terminating NUL. | |
451 | if n > 0 && buf[n-1] == '\x00' { | |
452 | n-- | |
453 | } | |
454 | return string(buf[0:n]), nil | |
455 | } | |
456 | ||
457 | func SysctlUint32(name string) (uint32, error) { | |
458 | return SysctlUint32Args(name) | |
459 | } | |
460 | ||
461 | func SysctlUint32Args(name string, args ...int) (uint32, error) { | |
462 | mib, err := sysctlmib(name, args...) | |
463 | if err != nil { | |
464 | return 0, err | |
465 | } | |
466 | ||
467 | n := uintptr(4) | |
468 | buf := make([]byte, 4) | |
469 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | |
470 | return 0, err | |
471 | } | |
472 | if n != 4 { | |
473 | return 0, EIO | |
474 | } | |
475 | return *(*uint32)(unsafe.Pointer(&buf[0])), nil | |
476 | } | |
477 | ||
478 | func SysctlUint64(name string, args ...int) (uint64, error) { | |
479 | mib, err := sysctlmib(name, args...) | |
480 | if err != nil { | |
481 | return 0, err | |
482 | } | |
483 | ||
484 | n := uintptr(8) | |
485 | buf := make([]byte, 8) | |
486 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | |
487 | return 0, err | |
488 | } | |
489 | if n != 8 { | |
490 | return 0, EIO | |
491 | } | |
492 | return *(*uint64)(unsafe.Pointer(&buf[0])), nil | |
493 | } | |
494 | ||
495 | func SysctlRaw(name string, args ...int) ([]byte, error) { | |
496 | mib, err := sysctlmib(name, args...) | |
497 | if err != nil { | |
498 | return nil, err | |
499 | } | |
500 | ||
501 | // Find size. | |
502 | n := uintptr(0) | |
503 | if err := sysctl(mib, nil, &n, nil, 0); err != nil { | |
504 | return nil, err | |
505 | } | |
506 | if n == 0 { | |
507 | return nil, nil | |
508 | } | |
509 | ||
510 | // Read into buffer of that size. | |
511 | buf := make([]byte, n) | |
512 | if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { | |
513 | return nil, err | |
514 | } | |
515 | ||
516 | // The actual call may return less than the original reported required | |
517 | // size so ensure we deal with that. | |
518 | return buf[:n], nil | |
519 | } | |
520 | ||
521 | //sys utimes(path string, timeval *[2]Timeval) (err error) | |
522 | ||
523 | func Utimes(path string, tv []Timeval) error { | |
524 | if tv == nil { | |
525 | return utimes(path, nil) | |
526 | } | |
527 | if len(tv) != 2 { | |
528 | return EINVAL | |
529 | } | |
530 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | |
531 | } | |
532 | ||
533 | func UtimesNano(path string, ts []Timespec) error { | |
534 | if ts == nil { | |
535 | err := utimensat(AT_FDCWD, path, nil, 0) | |
536 | if err != ENOSYS { | |
537 | return err | |
538 | } | |
539 | return utimes(path, nil) | |
540 | } | |
541 | if len(ts) != 2 { | |
542 | return EINVAL | |
543 | } | |
544 | // Darwin setattrlist can set nanosecond timestamps | |
545 | err := setattrlistTimes(path, ts, 0) | |
546 | if err != ENOSYS { | |
547 | return err | |
548 | } | |
549 | err = utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) | |
550 | if err != ENOSYS { | |
551 | return err | |
552 | } | |
553 | // Not as efficient as it could be because Timespec and | |
554 | // Timeval have different types in the different OSes | |
555 | tv := [2]Timeval{ | |
556 | NsecToTimeval(TimespecToNsec(ts[0])), | |
557 | NsecToTimeval(TimespecToNsec(ts[1])), | |
558 | } | |
559 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | |
560 | } | |
561 | ||
562 | func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { | |
563 | if ts == nil { | |
564 | return utimensat(dirfd, path, nil, flags) | |
565 | } | |
566 | if len(ts) != 2 { | |
567 | return EINVAL | |
568 | } | |
569 | err := setattrlistTimes(path, ts, flags) | |
570 | if err != ENOSYS { | |
571 | return err | |
572 | } | |
573 | return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) | |
574 | } | |
575 | ||
576 | //sys futimes(fd int, timeval *[2]Timeval) (err error) | |
577 | ||
578 | func Futimes(fd int, tv []Timeval) error { | |
579 | if tv == nil { | |
580 | return futimes(fd, nil) | |
581 | } | |
582 | if len(tv) != 2 { | |
583 | return EINVAL | |
584 | } | |
585 | return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | |
586 | } | |
587 | ||
588 | //sys fcntl(fd int, cmd int, arg int) (val int, err error) | |
589 | ||
590 | //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) | |
591 | ||
592 | func Poll(fds []PollFd, timeout int) (n int, err error) { | |
593 | if len(fds) == 0 { | |
594 | return poll(nil, 0, timeout) | |
595 | } | |
596 | return poll(&fds[0], len(fds), timeout) | |
597 | } | |
598 | ||
599 | // TODO: wrap | |
600 | // Acct(name nil-string) (err error) | |
601 | // Gethostuuid(uuid *byte, timeout *Timespec) (err error) | |
602 | // Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error) | |
603 | ||
604 | var mapper = &mmapper{ | |
605 | active: make(map[*byte][]byte), | |
606 | mmap: mmap, | |
607 | munmap: munmap, | |
608 | } | |
609 | ||
610 | func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { | |
611 | return mapper.Mmap(fd, offset, length, prot, flags) | |
612 | } | |
613 | ||
614 | func Munmap(b []byte) (err error) { | |
615 | return mapper.Munmap(b) | |
616 | } | |
617 | ||
618 | //sys Madvise(b []byte, behav int) (err error) | |
619 | //sys Mlock(b []byte) (err error) | |
620 | //sys Mlockall(flags int) (err error) | |
621 | //sys Mprotect(b []byte, prot int) (err error) | |
622 | //sys Msync(b []byte, flags int) (err error) | |
623 | //sys Munlock(b []byte) (err error) | |
624 | //sys Munlockall() (err error) |