1// Copyright 2009,2010 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// Darwin system calls.
6// This file is compiled as ordinary Go code,
7// but it is also input to mksyscall,
8// which parses the //sys lines and generates system call stubs.
9// Note that sometimes we use a lowercase //sys name and wrap
10// it in our own nicer implementation, either here or in
11// syscall_bsd.go or syscall_unix.go.
12
13package unix
14
15import (
16 "fmt"
17 "syscall"
18 "unsafe"
19)
20
21//sys closedir(dir uintptr) (err error)
22//sys readdir_r(dir uintptr, entry *Dirent, result **Dirent) (res Errno)
23
24func fdopendir(fd int) (dir uintptr, err error) {
25 r0, _, e1 := syscall_syscallPtr(libc_fdopendir_trampoline_addr, uintptr(fd), 0, 0)
26 dir = uintptr(r0)
27 if e1 != 0 {
28 err = errnoErr(e1)
29 }
30 return
31}
32
33var libc_fdopendir_trampoline_addr uintptr
34
35//go:cgo_import_dynamic libc_fdopendir fdopendir "/usr/lib/libSystem.B.dylib"
36
37func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
38 // Simulate Getdirentries using fdopendir/readdir_r/closedir.
39 // We store the number of entries to skip in the seek
40 // offset of fd. See issue #31368.
41 // It's not the full required semantics, but should handle the case
42 // of calling Getdirentries or ReadDirent repeatedly.
43 // It won't handle assigning the results of lseek to *basep, or handle
44 // the directory being edited underfoot.
45 skip, err := Seek(fd, 0, 1 /* SEEK_CUR */)
46 if err != nil {
47 return 0, err
48 }
49
50 // We need to duplicate the incoming file descriptor
51 // because the caller expects to retain control of it, but
52 // fdopendir expects to take control of its argument.
53 // Just Dup'ing the file descriptor is not enough, as the
54 // result shares underlying state. Use Openat to make a really
55 // new file descriptor referring to the same directory.
56 fd2, err := Openat(fd, ".", O_RDONLY, 0)
57 if err != nil {
58 return 0, err
59 }
60 d, err := fdopendir(fd2)
61 if err != nil {
62 Close(fd2)
63 return 0, err
64 }
65 defer closedir(d)
66
67 var cnt int64
68 for {
69 var entry Dirent
70 var entryp *Dirent
71 e := readdir_r(d, &entry, &entryp)
72 if e != 0 {
73 return n, errnoErr(e)
74 }
75 if entryp == nil {
76 break
77 }
78 if skip > 0 {
79 skip--
80 cnt++
81 continue
82 }
83
84 reclen := int(entry.Reclen)
85 if reclen > len(buf) {
86 // Not enough room. Return for now.
87 // The counter will let us know where we should start up again.
88 // Note: this strategy for suspending in the middle and
89 // restarting is O(n^2) in the length of the directory. Oh well.
90 break
91 }
92
93 // Copy entry into return buffer.
94 s := unsafe.Slice((*byte)(unsafe.Pointer(&entry)), reclen)
95 copy(buf, s)
96
97 buf = buf[reclen:]
98 n += reclen
99 cnt++
100 }
101 // Set the seek offset of the input fd to record
102 // how many files we've already returned.
103 _, err = Seek(fd, cnt, 0 /* SEEK_SET */)
104 if err != nil {
105 return n, err
106 }
107
108 return n, nil
109}
110
111// SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
112type SockaddrDatalink struct {
113 Len uint8
114 Family uint8
115 Index uint16
116 Type uint8
117 Nlen uint8
118 Alen uint8
119 Slen uint8
120 Data [12]int8
121 raw RawSockaddrDatalink
122}
123
124// SockaddrCtl implements the Sockaddr interface for AF_SYSTEM type sockets.
125type SockaddrCtl struct {
126 ID uint32
127 Unit uint32
128 raw RawSockaddrCtl
129}
130
131func (sa *SockaddrCtl) sockaddr() (unsafe.Pointer, _Socklen, error) {
132 sa.raw.Sc_len = SizeofSockaddrCtl
133 sa.raw.Sc_family = AF_SYSTEM
134 sa.raw.Ss_sysaddr = AF_SYS_CONTROL
135 sa.raw.Sc_id = sa.ID
136 sa.raw.Sc_unit = sa.Unit
137 return unsafe.Pointer(&sa.raw), SizeofSockaddrCtl, nil
138}
139
140// SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
141// SockaddrVM provides access to Darwin VM sockets: a mechanism that enables
142// bidirectional communication between a hypervisor and its guest virtual
143// machines.
144type SockaddrVM struct {
145 // CID and Port specify a context ID and port address for a VM socket.
146 // Guests have a unique CID, and hosts may have a well-known CID of:
147 // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
148 // - VMADDR_CID_LOCAL: refers to local communication (loopback).
149 // - VMADDR_CID_HOST: refers to other processes on the host.
150 CID uint32
151 Port uint32
152 raw RawSockaddrVM
153}
154
155func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
156 sa.raw.Len = SizeofSockaddrVM
157 sa.raw.Family = AF_VSOCK
158 sa.raw.Port = sa.Port
159 sa.raw.Cid = sa.CID
160
161 return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
162}
163
164func anyToSockaddrGOOS(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
165 switch rsa.Addr.Family {
166 case AF_SYSTEM:
167 pp := (*RawSockaddrCtl)(unsafe.Pointer(rsa))
168 if pp.Ss_sysaddr == AF_SYS_CONTROL {
169 sa := new(SockaddrCtl)
170 sa.ID = pp.Sc_id
171 sa.Unit = pp.Sc_unit
172 return sa, nil
173 }
174 case AF_VSOCK:
175 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
176 sa := &SockaddrVM{
177 CID: pp.Cid,
178 Port: pp.Port,
179 }
180 return sa, nil
181 }
182 return nil, EAFNOSUPPORT
183}
184
185// Some external packages rely on SYS___SYSCTL being defined to implement their
186// own sysctl wrappers. Provide it here, even though direct syscalls are no
187// longer supported on darwin.
188const SYS___SYSCTL = SYS_SYSCTL
189
190// Translate "kern.hostname" to []_C_int{0,1,2,3}.
191func nametomib(name string) (mib []_C_int, err error) {
192 const siz = unsafe.Sizeof(mib[0])
193
194 // NOTE(rsc): It seems strange to set the buffer to have
195 // size CTL_MAXNAME+2 but use only CTL_MAXNAME
196 // as the size. I don't know why the +2 is here, but the
197 // kernel uses +2 for its own implementation of this function.
198 // I am scared that if we don't include the +2 here, the kernel
199 // will silently write 2 words farther than we specify
200 // and we'll get memory corruption.
201 var buf [CTL_MAXNAME + 2]_C_int
202 n := uintptr(CTL_MAXNAME) * siz
203
204 p := (*byte)(unsafe.Pointer(&buf[0]))
205 bytes, err := ByteSliceFromString(name)
206 if err != nil {
207 return nil, err
208 }
209
210 // Magic sysctl: "setting" 0.3 to a string name
211 // lets you read back the array of integers form.
212 if err = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); err != nil {
213 return nil, err
214 }
215 return buf[0 : n/siz], nil
216}
217
218func direntIno(buf []byte) (uint64, bool) {
219 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
220}
221
222func direntReclen(buf []byte) (uint64, bool) {
223 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
224}
225
226func direntNamlen(buf []byte) (uint64, bool) {
227 return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
228}
229
230func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
231func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
232func PtraceDenyAttach() (err error) { return ptrace(PT_DENY_ATTACH, 0, 0, 0) }
233
234//sysnb pipe(p *[2]int32) (err error)
235
236func Pipe(p []int) (err error) {
237 if len(p) != 2 {
238 return EINVAL
239 }
240 var x [2]int32
241 err = pipe(&x)
242 if err == nil {
243 p[0] = int(x[0])
244 p[1] = int(x[1])
245 }
246 return
247}
248
249func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
250 var _p0 unsafe.Pointer
251 var bufsize uintptr
252 if len(buf) > 0 {
253 _p0 = unsafe.Pointer(&buf[0])
254 bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
255 }
256 return getfsstat(_p0, bufsize, flags)
257}
258
259func xattrPointer(dest []byte) *byte {
260 // It's only when dest is set to NULL that the OS X implementations of
261 // getxattr() and listxattr() return the current sizes of the named attributes.
262 // An empty byte array is not sufficient. To maintain the same behaviour as the
263 // linux implementation, we wrap around the system calls and pass in NULL when
264 // dest is empty.
265 var destp *byte
266 if len(dest) > 0 {
267 destp = &dest[0]
268 }
269 return destp
270}
271
272//sys getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
273
274func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
275 return getxattr(path, attr, xattrPointer(dest), len(dest), 0, 0)
276}
277
278func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
279 return getxattr(link, attr, xattrPointer(dest), len(dest), 0, XATTR_NOFOLLOW)
280}
281
282//sys fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error)
283
284func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
285 return fgetxattr(fd, attr, xattrPointer(dest), len(dest), 0, 0)
286}
287
288//sys setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error)
289
290func Setxattr(path string, attr string, data []byte, flags int) (err error) {
291 // The parameters for the OS X implementation vary slightly compared to the
292 // linux system call, specifically the position parameter:
293 //
294 // linux:
295 // int setxattr(
296 // const char *path,
297 // const char *name,
298 // const void *value,
299 // size_t size,
300 // int flags
301 // );
302 //
303 // darwin:
304 // int setxattr(
305 // const char *path,
306 // const char *name,
307 // void *value,
308 // size_t size,
309 // u_int32_t position,
310 // int options
311 // );
312 //
313 // position specifies the offset within the extended attribute. In the
314 // current implementation, only the resource fork extended attribute makes
315 // use of this argument. For all others, position is reserved. We simply
316 // default to setting it to zero.
317 return setxattr(path, attr, xattrPointer(data), len(data), 0, flags)
318}
319
320func Lsetxattr(link string, attr string, data []byte, flags int) (err error) {
321 return setxattr(link, attr, xattrPointer(data), len(data), 0, flags|XATTR_NOFOLLOW)
322}
323
324//sys fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error)
325
326func Fsetxattr(fd int, attr string, data []byte, flags int) (err error) {
327 return fsetxattr(fd, attr, xattrPointer(data), len(data), 0, 0)
328}
329
330//sys removexattr(path string, attr string, options int) (err error)
331
332func Removexattr(path string, attr string) (err error) {
333 // We wrap around and explicitly zero out the options provided to the OS X
334 // implementation of removexattr, we do so for interoperability with the
335 // linux variant.
336 return removexattr(path, attr, 0)
337}
338
339func Lremovexattr(link string, attr string) (err error) {
340 return removexattr(link, attr, XATTR_NOFOLLOW)
341}
342
343//sys fremovexattr(fd int, attr string, options int) (err error)
344
345func Fremovexattr(fd int, attr string) (err error) {
346 return fremovexattr(fd, attr, 0)
347}
348
349//sys listxattr(path string, dest *byte, size int, options int) (sz int, err error)
350
351func Listxattr(path string, dest []byte) (sz int, err error) {
352 return listxattr(path, xattrPointer(dest), len(dest), 0)
353}
354
355func Llistxattr(link string, dest []byte) (sz int, err error) {
356 return listxattr(link, xattrPointer(dest), len(dest), XATTR_NOFOLLOW)
357}
358
359//sys flistxattr(fd int, dest *byte, size int, options int) (sz int, err error)
360
361func Flistxattr(fd int, dest []byte) (sz int, err error) {
362 return flistxattr(fd, xattrPointer(dest), len(dest), 0)
363}
364
365//sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)
366
367/*
368 * Wrapped
369 */
370
371//sys fcntl(fd int, cmd int, arg int) (val int, err error)
372
373//sys kill(pid int, signum int, posix int) (err error)
374
375func Kill(pid int, signum syscall.Signal) (err error) { return kill(pid, int(signum), 1) }
376
377//sys ioctl(fd int, req uint, arg uintptr) (err error)
378//sys ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL
379
380func IoctlCtlInfo(fd int, ctlInfo *CtlInfo) error {
381 return ioctlPtr(fd, CTLIOCGINFO, unsafe.Pointer(ctlInfo))
382}
383
384// IfreqMTU is struct ifreq used to get or set a network device's MTU.
385type IfreqMTU struct {
386 Name [IFNAMSIZ]byte
387 MTU int32
388}
389
390// IoctlGetIfreqMTU performs the SIOCGIFMTU ioctl operation on fd to get the MTU
391// of the network device specified by ifname.
392func IoctlGetIfreqMTU(fd int, ifname string) (*IfreqMTU, error) {
393 var ifreq IfreqMTU
394 copy(ifreq.Name[:], ifname)
395 err := ioctlPtr(fd, SIOCGIFMTU, unsafe.Pointer(&ifreq))
396 return &ifreq, err
397}
398
399// IoctlSetIfreqMTU performs the SIOCSIFMTU ioctl operation on fd to set the MTU
400// of the network device specified by ifreq.Name.
401func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error {
402 return ioctlPtr(fd, SIOCSIFMTU, unsafe.Pointer(ifreq))
403}
404
405//sys renamexNp(from string, to string, flag uint32) (err error)
406
407func RenamexNp(from string, to string, flag uint32) (err error) {
408 return renamexNp(from, to, flag)
409}
410
411//sys renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error)
412
413func RenameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) {
414 return renameatxNp(fromfd, from, tofd, to, flag)
415}
416
417//sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL
418
419func Uname(uname *Utsname) error {
420 mib := []_C_int{CTL_KERN, KERN_OSTYPE}
421 n := unsafe.Sizeof(uname.Sysname)
422 if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil {
423 return err
424 }
425
426 mib = []_C_int{CTL_KERN, KERN_HOSTNAME}
427 n = unsafe.Sizeof(uname.Nodename)
428 if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil {
429 return err
430 }
431
432 mib = []_C_int{CTL_KERN, KERN_OSRELEASE}
433 n = unsafe.Sizeof(uname.Release)
434 if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil {
435 return err
436 }
437
438 mib = []_C_int{CTL_KERN, KERN_VERSION}
439 n = unsafe.Sizeof(uname.Version)
440 if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil {
441 return err
442 }
443
444 // The version might have newlines or tabs in it, convert them to
445 // spaces.
446 for i, b := range uname.Version {
447 if b == '\n' || b == '\t' {
448 if i == len(uname.Version)-1 {
449 uname.Version[i] = 0
450 } else {
451 uname.Version[i] = ' '
452 }
453 }
454 }
455
456 mib = []_C_int{CTL_HW, HW_MACHINE}
457 n = unsafe.Sizeof(uname.Machine)
458 if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil {
459 return err
460 }
461
462 return nil
463}
464
465func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
466 if raceenabled {
467 raceReleaseMerge(unsafe.Pointer(&ioSync))
468 }
469 var length = int64(count)
470 err = sendfile(infd, outfd, *offset, &length, nil, 0)
471 written = int(length)
472 return
473}
474
475func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
476 var value IPMreqn
477 vallen := _Socklen(SizeofIPMreqn)
478 errno := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
479 return &value, errno
480}
481
482func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
483 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
484}
485
486// GetsockoptXucred is a getsockopt wrapper that returns an Xucred struct.
487// The usual level and opt are SOL_LOCAL and LOCAL_PEERCRED, respectively.
488func GetsockoptXucred(fd, level, opt int) (*Xucred, error) {
489 x := new(Xucred)
490 vallen := _Socklen(SizeofXucred)
491 err := getsockopt(fd, level, opt, unsafe.Pointer(x), &vallen)
492 return x, err
493}
494
495func GetsockoptTCPConnectionInfo(fd, level, opt int) (*TCPConnectionInfo, error) {
496 var value TCPConnectionInfo
497 vallen := _Socklen(SizeofTCPConnectionInfo)
498 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
499 return &value, err
500}
501
502func SysctlKinfoProc(name string, args ...int) (*KinfoProc, error) {
503 mib, err := sysctlmib(name, args...)
504 if err != nil {
505 return nil, err
506 }
507
508 var kinfo KinfoProc
509 n := uintptr(SizeofKinfoProc)
510 if err := sysctl(mib, (*byte)(unsafe.Pointer(&kinfo)), &n, nil, 0); err != nil {
511 return nil, err
512 }
513 if n != SizeofKinfoProc {
514 return nil, EIO
515 }
516 return &kinfo, nil
517}
518
519func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) {
520 mib, err := sysctlmib(name, args...)
521 if err != nil {
522 return nil, err
523 }
524
525 for {
526 // Find size.
527 n := uintptr(0)
528 if err := sysctl(mib, nil, &n, nil, 0); err != nil {
529 return nil, err
530 }
531 if n == 0 {
532 return nil, nil
533 }
534 if n%SizeofKinfoProc != 0 {
535 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
536 }
537
538 // Read into buffer of that size.
539 buf := make([]KinfoProc, n/SizeofKinfoProc)
540 if err := sysctl(mib, (*byte)(unsafe.Pointer(&buf[0])), &n, nil, 0); err != nil {
541 if err == ENOMEM {
542 // Process table grew. Try again.
543 continue
544 }
545 return nil, err
546 }
547 if n%SizeofKinfoProc != 0 {
548 return nil, fmt.Errorf("sysctl() returned a size of %d, which is not a multiple of %d", n, SizeofKinfoProc)
549 }
550
551 // The actual call may return less than the original reported required
552 // size so ensure we deal with that.
553 return buf[:n/SizeofKinfoProc], nil
554 }
555}
556
557//sys pthread_chdir_np(path string) (err error)
558
559func PthreadChdir(path string) (err error) {
560 return pthread_chdir_np(path)
561}
562
563//sys pthread_fchdir_np(fd int) (err error)
564
565func PthreadFchdir(fd int) (err error) {
566 return pthread_fchdir_np(fd)
567}
568
569// Connectx calls connectx(2) to initiate a connection on a socket.
570//
571// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument.
572//
573// - srcIf is the optional source interface index. 0 means unspecified.
574// - srcAddr is the optional source address. nil means unspecified.
575// - dstAddr is the destination address.
576//
577// On success, Connectx returns the number of bytes enqueued for transmission.
578func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) {
579 endpoints := SaEndpoints{
580 Srcif: srcIf,
581 }
582
583 if srcAddr != nil {
584 addrp, addrlen, err := srcAddr.sockaddr()
585 if err != nil {
586 return 0, err
587 }
588 endpoints.Srcaddr = (*RawSockaddr)(addrp)
589 endpoints.Srcaddrlen = uint32(addrlen)
590 }
591
592 if dstAddr != nil {
593 addrp, addrlen, err := dstAddr.sockaddr()
594 if err != nil {
595 return 0, err
596 }
597 endpoints.Dstaddr = (*RawSockaddr)(addrp)
598 endpoints.Dstaddrlen = uint32(addrlen)
599 }
600
601 err = connectx(fd, &endpoints, associd, flags, iov, &n, connid)
602 return
603}
604
605// sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
606const minIovec = 8
607
608func Readv(fd int, iovs [][]byte) (n int, err error) {
609 if !darwinKernelVersionMin(11, 0, 0) {
610 return 0, ENOSYS
611 }
612
613 iovecs := make([]Iovec, 0, minIovec)
614 iovecs = appendBytes(iovecs, iovs)
615 n, err = readv(fd, iovecs)
616 readvRacedetect(iovecs, n, err)
617 return n, err
618}
619
620func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
621 if !darwinKernelVersionMin(11, 0, 0) {
622 return 0, ENOSYS
623 }
624 iovecs := make([]Iovec, 0, minIovec)
625 iovecs = appendBytes(iovecs, iovs)
626 n, err = preadv(fd, iovecs, offset)
627 readvRacedetect(iovecs, n, err)
628 return n, err
629}
630
631func Writev(fd int, iovs [][]byte) (n int, err error) {
632 if !darwinKernelVersionMin(11, 0, 0) {
633 return 0, ENOSYS
634 }
635
636 iovecs := make([]Iovec, 0, minIovec)
637 iovecs = appendBytes(iovecs, iovs)
638 if raceenabled {
639 raceReleaseMerge(unsafe.Pointer(&ioSync))
640 }
641 n, err = writev(fd, iovecs)
642 writevRacedetect(iovecs, n)
643 return n, err
644}
645
646func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
647 if !darwinKernelVersionMin(11, 0, 0) {
648 return 0, ENOSYS
649 }
650
651 iovecs := make([]Iovec, 0, minIovec)
652 iovecs = appendBytes(iovecs, iovs)
653 if raceenabled {
654 raceReleaseMerge(unsafe.Pointer(&ioSync))
655 }
656 n, err = pwritev(fd, iovecs, offset)
657 writevRacedetect(iovecs, n)
658 return n, err
659}
660
661func appendBytes(vecs []Iovec, bs [][]byte) []Iovec {
662 for _, b := range bs {
663 var v Iovec
664 v.SetLen(len(b))
665 if len(b) > 0 {
666 v.Base = &b[0]
667 } else {
668 v.Base = (*byte)(unsafe.Pointer(&_zero))
669 }
670 vecs = append(vecs, v)
671 }
672 return vecs
673}
674
675func writevRacedetect(iovecs []Iovec, n int) {
676 if !raceenabled {
677 return
678 }
679 for i := 0; n > 0 && i < len(iovecs); i++ {
680 m := int(iovecs[i].Len)
681 if m > n {
682 m = n
683 }
684 n -= m
685 if m > 0 {
686 raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
687 }
688 }
689}
690
691func readvRacedetect(iovecs []Iovec, n int, err error) {
692 if !raceenabled {
693 return
694 }
695 for i := 0; n > 0 && i < len(iovecs); i++ {
696 m := int(iovecs[i].Len)
697 if m > n {
698 m = n
699 }
700 n -= m
701 if m > 0 {
702 raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
703 }
704 }
705 if err == nil {
706 raceAcquire(unsafe.Pointer(&ioSync))
707 }
708}
709
710func darwinMajorMinPatch() (maj, min, patch int, err error) {
711 var un Utsname
712 err = Uname(&un)
713 if err != nil {
714 return
715 }
716
717 var mmp [3]int
718 c := 0
719Loop:
720 for _, b := range un.Release[:] {
721 switch {
722 case b >= '0' && b <= '9':
723 mmp[c] = 10*mmp[c] + int(b-'0')
724 case b == '.':
725 c++
726 if c > 2 {
727 return 0, 0, 0, ENOTSUP
728 }
729 case b == 0:
730 break Loop
731 default:
732 return 0, 0, 0, ENOTSUP
733 }
734 }
735 if c != 2 {
736 return 0, 0, 0, ENOTSUP
737 }
738 return mmp[0], mmp[1], mmp[2], nil
739}
740
741func darwinKernelVersionMin(maj, min, patch int) bool {
742 actualMaj, actualMin, actualPatch, err := darwinMajorMinPatch()
743 if err != nil {
744 return false
745 }
746 return actualMaj > maj || actualMaj == maj && (actualMin > min || actualMin == min && actualPatch >= patch)
747}
748
749//sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
750
751//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
752//sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error)
753//sys shmdt(addr uintptr) (err error)
754//sys shmget(key int, size int, flag int) (id int, err error)
755
756/*
757 * Exposed directly
758 */
759//sys Access(path string, mode uint32) (err error)
760//sys Adjtime(delta *Timeval, olddelta *Timeval) (err error)
761//sys Chdir(path string) (err error)
762//sys Chflags(path string, flags int) (err error)
763//sys Chmod(path string, mode uint32) (err error)
764//sys Chown(path string, uid int, gid int) (err error)
765//sys Chroot(path string) (err error)
766//sys ClockGettime(clockid int32, time *Timespec) (err error)
767//sys Close(fd int) (err error)
768//sys Clonefile(src string, dst string, flags int) (err error)
769//sys Clonefileat(srcDirfd int, src string, dstDirfd int, dst string, flags int) (err error)
770//sys Dup(fd int) (nfd int, err error)
771//sys Dup2(from int, to int) (err error)
772//sys Exchangedata(path1 string, path2 string, options int) (err error)
773//sys Exit(code int)
774//sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
775//sys Fchdir(fd int) (err error)
776//sys Fchflags(fd int, flags int) (err error)
777//sys Fchmod(fd int, mode uint32) (err error)
778//sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
779//sys Fchown(fd int, uid int, gid int) (err error)
780//sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
781//sys Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error)
782//sys Flock(fd int, how int) (err error)
783//sys Fpathconf(fd int, name int) (val int, err error)
784//sys Fsync(fd int) (err error)
785//sys Ftruncate(fd int, length int64) (err error)
786//sys Getcwd(buf []byte) (n int, err error)
787//sys Getdtablesize() (size int)
788//sysnb Getegid() (egid int)
789//sysnb Geteuid() (uid int)
790//sysnb Getgid() (gid int)
791//sysnb Getpgid(pid int) (pgid int, err error)
792//sysnb Getpgrp() (pgrp int)
793//sysnb Getpid() (pid int)
794//sysnb Getppid() (ppid int)
795//sys Getpriority(which int, who int) (prio int, err error)
796//sysnb Getrlimit(which int, lim *Rlimit) (err error)
797//sysnb Getrusage(who int, rusage *Rusage) (err error)
798//sysnb Getsid(pid int) (sid int, err error)
799//sysnb Gettimeofday(tp *Timeval) (err error)
800//sysnb Getuid() (uid int)
801//sysnb Issetugid() (tainted bool)
802//sys Kqueue() (fd int, err error)
803//sys Lchown(path string, uid int, gid int) (err error)
804//sys Link(path string, link string) (err error)
805//sys Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error)
806//sys Listen(s int, backlog int) (err error)
807//sys Mkdir(path string, mode uint32) (err error)
808//sys Mkdirat(dirfd int, path string, mode uint32) (err error)
809//sys Mkfifo(path string, mode uint32) (err error)
810//sys Mknod(path string, mode uint32, dev int) (err error)
811//sys Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error)
812//sys Open(path string, mode int, perm uint32) (fd int, err error)
813//sys Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error)
814//sys Pathconf(path string, name int) (val int, err error)
815//sys pread(fd int, p []byte, offset int64) (n int, err error)
816//sys pwrite(fd int, p []byte, offset int64) (n int, err error)
817//sys read(fd int, p []byte) (n int, err error)
818//sys Readlink(path string, buf []byte) (n int, err error)
819//sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error)
820//sys Rename(from string, to string) (err error)
821//sys Renameat(fromfd int, from string, tofd int, to string) (err error)
822//sys Revoke(path string) (err error)
823//sys Rmdir(path string) (err error)
824//sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_LSEEK
825//sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
826//sys Setattrlist(path string, attrlist *Attrlist, attrBuf []byte, options int) (err error)
827//sys Setegid(egid int) (err error)
828//sysnb Seteuid(euid int) (err error)
829//sysnb Setgid(gid int) (err error)
830//sys Setlogin(name string) (err error)
831//sysnb Setpgid(pid int, pgid int) (err error)
832//sys Setpriority(which int, who int, prio int) (err error)
833//sys Setprivexec(flag int) (err error)
834//sysnb Setregid(rgid int, egid int) (err error)
835//sysnb Setreuid(ruid int, euid int) (err error)
836//sysnb Setsid() (pid int, err error)
837//sysnb Settimeofday(tp *Timeval) (err error)
838//sysnb Setuid(uid int) (err error)
839//sys Symlink(path string, link string) (err error)
840//sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
841//sys Sync() (err error)
842//sys Truncate(path string, length int64) (err error)
843//sys Umask(newmask int) (oldmask int)
844//sys Undelete(path string) (err error)
845//sys Unlink(path string) (err error)
846//sys Unlinkat(dirfd int, path string, flags int) (err error)
847//sys Unmount(path string, flags int) (err error)
848//sys write(fd int, p []byte) (n int, err error)
849//sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
850//sys munmap(addr uintptr, length uintptr) (err error)
851//sys readv(fd int, iovecs []Iovec) (n int, err error)
852//sys preadv(fd int, iovecs []Iovec, offset int64) (n int, err error)
853//sys writev(fd int, iovecs []Iovec) (n int, err error)
854//sys pwritev(fd int, iovecs []Iovec, offset int64) (n int, err error)