| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Darwin system calls. |
| // This file is compiled as ordinary Go code, |
| // but it is also input to mksyscall, |
| // which parses the //sys lines and generates system call stubs. |
| // Note that sometimes we use a lowercase //sys name and |
| // wrap it in our own nicer implementation. |
| |
| package syscall |
| |
| import "unsafe" |
| |
| const OS = "darwin" |
| |
| /* |
| * Pseudo-system calls |
| */ |
| // The const provides a compile-time constant so clients |
| // can adjust to whether there is a working Getwd and avoid |
| // even linking this function into the binary. See ../os/getwd.go. |
| const ImplementsGetwd = false |
| |
| func Getwd() (string, int) { |
| return "", ENOTSUP; |
| } |
| |
| |
| /* |
| * Wrapped |
| */ |
| |
| //sys getgroups(ngid int, gid *_Gid_t) (n int, errno int) |
| //sys setgroups(ngid int, gid *_Gid_t) (errno int) |
| |
| func Getgroups() (gids []int, errno int) { |
| n, err := getgroups(0, nil); |
| if err != 0 { |
| return nil, errno; |
| } |
| if n == 0 { |
| return nil, 0; |
| } |
| |
| // Sanity check group count. Max is 16 on BSD. |
| if n < 0 || n > 1000 { |
| return nil, EINVAL; |
| } |
| |
| a := make([]_Gid_t, n); |
| n, err = getgroups(n, &a[0]); |
| if err != 0 { |
| return nil, errno; |
| } |
| gids = make([]int, n); |
| for i, v := range a[0:n] { |
| gids[i] = int(v); |
| } |
| return; |
| } |
| |
| func Setgroups(gids []int) (errno int) { |
| if len(gids) == 0 { |
| return setgroups(0, nil); |
| } |
| |
| a := make([]_Gid_t, len(gids)); |
| for i, v := range gids { |
| a[i] = _Gid_t(v); |
| } |
| return setgroups(len(a), &a[0]); |
| } |
| |
| // Wait status is 7 bits at bottom, either 0 (exited), |
| // 0x7F (stopped), or a signal number that caused an exit. |
| // The 0x80 bit is whether there was a core dump. |
| // An extra number (exit code, signal causing a stop) |
| // is in the high bits. |
| |
| type WaitStatus uint32 |
| |
| const ( |
| mask = 0x7F; |
| core = 0x80; |
| shift = 8; |
| |
| exited = 0; |
| stopped = 0x7F; |
| ) |
| |
| func (w WaitStatus) Exited() bool { |
| return w&mask == exited; |
| } |
| |
| func (w WaitStatus) ExitStatus() int { |
| if w&mask != exited { |
| return -1; |
| } |
| return int(w >> shift); |
| } |
| |
| func (w WaitStatus) Signaled() bool { |
| return w&mask != stopped && w&mask != 0; |
| } |
| |
| func (w WaitStatus) Signal() int { |
| sig := int(w & mask); |
| if sig == stopped || sig == 0 { |
| return -1; |
| } |
| return sig; |
| } |
| |
| func (w WaitStatus) CoreDump() bool { |
| return w.Signaled() && w&core != 0; |
| } |
| |
| func (w WaitStatus) Stopped() bool { |
| return w&mask == stopped && w>>shift != SIGSTOP; |
| } |
| |
| func (w WaitStatus) Continued() bool { |
| return w&mask == stopped && w>>shift == SIGSTOP; |
| } |
| |
| func (w WaitStatus) StopSignal() int { |
| if !w.Stopped() { |
| return -1; |
| } |
| return int(w >> shift) & 0xFF; |
| } |
| |
| func (w WaitStatus) TrapCause() int { |
| // Darwin doesn't have trap causes |
| return -1; |
| } |
| |
| //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, errno int) |
| func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, errno int) { |
| var status _C_int; |
| wpid, errno = wait4(pid, &status, options, rusage); |
| if wstatus != nil { |
| *wstatus = WaitStatus(status); |
| } |
| return; |
| } |
| |
| //sys pipe() (r int, w int, errno int) |
| func Pipe(p []int) (errno int) { |
| if len(p) != 2 { |
| return EINVAL; |
| } |
| p[0], p[1], errno = pipe(); |
| return; |
| } |
| |
| func Sleep(ns int64) (errno int) { |
| tv := NsecToTimeval(ns); |
| return Select(0, nil, nil, nil, &tv); |
| } |
| |
| //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, errno int) |
| //sys bind(s int, addr uintptr, addrlen _Socklen) (errno int) |
| //sys connect(s int, addr uintptr, addrlen _Socklen) (errno int) |
| //sys socket(domain int, typ int, proto int) (fd int, errno int) |
| //sys setsockopt(s int, level int, name int, val uintptr, vallen int) (errno int) |
| //sys getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (errno int) |
| //sys getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (errno int) |
| |
| // For testing: clients can set this flag to force |
| // creation of IPv6 sockets to return EAFNOSUPPORT. |
| var SocketDisableIPv6 bool |
| |
| type Sockaddr interface { |
| sockaddr() (ptr uintptr, len _Socklen, errno int); // lowercase; only we can define Sockaddrs |
| } |
| |
| type SockaddrInet4 struct { |
| Port int; |
| Addr [4]byte; |
| raw RawSockaddrInet4; |
| } |
| |
| func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, int) { |
| if sa.Port < 0 || sa.Port > 0xFFFF { |
| return 0, 0, EINVAL; |
| } |
| sa.raw.Len = SizeofSockaddrInet4; |
| sa.raw.Family = AF_INET; |
| p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)); |
| p[0] = byte(sa.Port>>8); |
| p[1] = byte(sa.Port); |
| for i := 0; i < len(sa.Addr); i++ { |
| sa.raw.Addr[i] = sa.Addr[i]; |
| } |
| return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0; |
| } |
| |
| type SockaddrInet6 struct { |
| Port int; |
| Addr [16]byte; |
| raw RawSockaddrInet6; |
| } |
| |
| func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, int) { |
| if sa.Port < 0 || sa.Port > 0xFFFF { |
| return 0, 0, EINVAL; |
| } |
| sa.raw.Len = SizeofSockaddrInet6; |
| sa.raw.Family = AF_INET6; |
| p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)); |
| p[0] = byte(sa.Port>>8); |
| p[1] = byte(sa.Port); |
| for i := 0; i < len(sa.Addr); i++ { |
| sa.raw.Addr[i] = sa.Addr[i]; |
| } |
| return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0; |
| } |
| |
| type SockaddrUnix struct { |
| Name string; |
| raw RawSockaddrUnix; |
| } |
| |
| func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, int) { |
| name := sa.Name; |
| n := len(name); |
| if n >= len(sa.raw.Path) || n == 0 { |
| return 0, 0, EINVAL; |
| } |
| sa.raw.Len = byte(3 + n); // 2 for Family, Len; 1 for NUL |
| sa.raw.Family = AF_UNIX; |
| for i := 0; i < n; i++ { |
| sa.raw.Path[i] = int8(name[i]); |
| } |
| return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0; |
| } |
| |
| func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, int) { |
| switch rsa.Addr.Family { |
| case AF_UNIX: |
| pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)); |
| if pp.Len < 3 || pp.Len > SizeofSockaddrUnix { |
| return nil, EINVAL |
| } |
| sa := new(SockaddrUnix); |
| n := int(pp.Len) - 3; // subtract leading Family, Len, terminating NUL |
| for i := 0; i < n; i++ { |
| if pp.Path[i] == 0 { |
| // found early NUL; assume Len is overestimating |
| n = i; |
| break; |
| } |
| } |
| bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0])); |
| sa.Name = string(bytes[0:n]); |
| return sa, 0; |
| |
| case AF_INET: |
| pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)); |
| sa := new(SockaddrInet4); |
| p := (*[2]byte)(unsafe.Pointer(&pp.Port)); |
| sa.Port = int(p[0])<<8 + int(p[1]); |
| for i := 0; i < len(sa.Addr); i++ { |
| sa.Addr[i] = pp.Addr[i]; |
| } |
| return sa, 0; |
| |
| case AF_INET6: |
| pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)); |
| sa := new(SockaddrInet6); |
| p := (*[2]byte)(unsafe.Pointer(&pp.Port)); |
| sa.Port = int(p[0])<<8 + int(p[1]); |
| for i := 0; i < len(sa.Addr); i++ { |
| sa.Addr[i] = pp.Addr[i]; |
| } |
| return sa, 0; |
| } |
| return nil, EAFNOSUPPORT; |
| } |
| |
| func Accept(fd int) (nfd int, sa Sockaddr, errno int) { |
| var rsa RawSockaddrAny; |
| var len _Socklen = SizeofSockaddrAny; |
| nfd, errno = accept(fd, &rsa, &len); |
| if errno != 0 { |
| return; |
| } |
| sa, errno = anyToSockaddr(&rsa); |
| if errno != 0 { |
| Close(nfd); |
| nfd = 0; |
| } |
| return; |
| } |
| |
| func Getsockname(fd int) (sa Sockaddr, errno int) { |
| var rsa RawSockaddrAny; |
| var len _Socklen = SizeofSockaddrAny; |
| if errno = getsockname(fd, &rsa, &len); errno != 0 { |
| return; |
| } |
| return anyToSockaddr(&rsa); |
| } |
| |
| func Getpeername(fd int) (sa Sockaddr, errno int) { |
| var rsa RawSockaddrAny; |
| var len _Socklen = SizeofSockaddrAny; |
| if errno = getpeername(fd, &rsa, &len); errno != 0 { |
| return; |
| } |
| return anyToSockaddr(&rsa); |
| } |
| |
| func Bind(fd int, sa Sockaddr) (errno int) { |
| ptr, n, err := sa.sockaddr(); |
| if err != 0 { |
| return err; |
| } |
| return bind(fd, ptr, n); |
| } |
| |
| func Connect(fd int, sa Sockaddr) (errno int) { |
| ptr, n, err := sa.sockaddr(); |
| if err != 0 { |
| return err; |
| } |
| return connect(fd, ptr, n); |
| } |
| |
| func Socket(domain, typ, proto int) (fd, errno int) { |
| if domain == AF_INET6 && SocketDisableIPv6 { |
| return -1, EAFNOSUPPORT |
| } |
| fd, errno = socket(domain, typ, proto); |
| return; |
| } |
| |
| func SetsockoptInt(fd, level, opt int, value int) (errno int) { |
| var n = int32(value); |
| return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), 4); |
| } |
| |
| func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (errno int) { |
| return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(tv)), unsafe.Sizeof(*tv)); |
| } |
| |
| func SetsockoptLinger(fd, level, opt int, l *Linger) (errno int) { |
| return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(l)), unsafe.Sizeof(*l)); |
| } |
| |
| //sys kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, errno int) |
| func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, errno int) { |
| var change, event uintptr; |
| if len(changes) > 0 { |
| change = uintptr(unsafe.Pointer(&changes[0])); |
| } |
| if len(events) > 0 { |
| event = uintptr(unsafe.Pointer(&events[0])); |
| } |
| return kevent(kq, change, len(changes), event, len(events), timeout); |
| } |
| |
| //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (errno int) = SYS___SYSCTL |
| |
| // Translate "kern.hostname" to []_C_int{0,1,2,3}. |
| func nametomib(name string) (mib []_C_int, errno int) { |
| const CTL_MAXNAME = 12; |
| const siz = uintptr(unsafe.Sizeof(mib[0])); |
| |
| // NOTE(rsc): It seems strange to set the buffer to have |
| // size CTL_MAXNAME+2 but use only CTL_MAXNAME |
| // as the size. I don't know why the +2 is here, but the |
| // kernel uses +2 for its own implementation of this function. |
| // I am scared that if we don't include the +2 here, the kernel |
| // will silently write 2 words farther than we specify |
| // and we'll get memory corruption. |
| var buf [CTL_MAXNAME+2] _C_int; |
| n := uintptr(CTL_MAXNAME)*siz; |
| |
| p := (*byte)(unsafe.Pointer(&buf[0])); |
| bytes := StringByteSlice(name); |
| |
| // Magic sysctl: "setting" 0.3 to a string name |
| // lets you read back the array of integers form. |
| if errno = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); errno != 0 { |
| return nil, errno; |
| } |
| return buf[0:n/siz], 0; |
| } |
| |
| func Sysctl(name string) (value string, errno int) { |
| // Translate name to mib number. |
| mib, errno := nametomib(name); |
| if errno != 0 { |
| return "", errno; |
| } |
| |
| // Find size. |
| n := uintptr(0); |
| if errno = sysctl(mib, nil, &n, nil, 0); errno != 0 { |
| return "", errno; |
| } |
| if n == 0 { |
| return "", 0; |
| } |
| |
| // Read into buffer of that size. |
| buf := make([]byte, n); |
| if errno = sysctl(mib, &buf[0], &n, nil, 0); errno != 0 { |
| return "", errno; |
| } |
| |
| // Throw away terminating NUL. |
| if n > 0 && buf[n-1] == '\x00' { |
| n--; |
| } |
| return string(buf[0:n]), 0; |
| } |
| |
| func SysctlUint32(name string) (value uint32, errno int) { |
| // Translate name to mib number. |
| mib, errno := nametomib(name); |
| if errno != 0 { |
| return 0, errno; |
| } |
| |
| // Read into buffer of that size. |
| n := uintptr(4); |
| buf := make([]byte, 4); |
| if errno = sysctl(mib, &buf[0], &n, nil, 0); errno != 0 { |
| return 0, errno; |
| } |
| if n != 4 { |
| return 0, EIO; |
| } |
| return *(*uint32)(unsafe.Pointer(&buf[0])), 0; |
| } |
| |
| // TODO: wrap |
| // Acct(name nil-string) (errno int) |
| // Futimes(fd int, timeval *Timeval) (errno int) // Pointer to 2 timevals! |
| // Gethostuuid(uuid *byte, timeout *Timespec) (errno int) |
| // Getsockopt(s int, level int, name int, val *byte, vallen *int) (errno int) |
| // Madvise(addr *byte, len int, behav int) (errno int) |
| // Mprotect(addr *byte, len int, prot int) (errno int) |
| // Msync(addr *byte, len int, flags int) (errno int) |
| // Munmap(addr *byte, len int) (errno int) |
| // Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, errno int) |
| // Recvfrom(s int, buf *byte, nbuf int, flags int, from *Sockaddr, fromlen *int) (n int, errno int) |
| // Recvmsg(s int, msg *Msghdr, flags int) (n int, errno int) |
| // Sendmsg(s int, msg *Msghdr, flags int) (n int, errno int) |
| // Sendto(s int, buf *byte, nbuf int, flags int, to *Sockaddr, addrlen int) (errno int) |
| // Utimes(path string, timeval *Timeval) (errno int) // Pointer to 2 timevals! |
| //sys fcntl(fd int, cmd int, arg int) (val int, errno int) |
| |
| |
| /* |
| * Exposed directly |
| */ |
| //sys Access(path string, flags int) (errno int) |
| //sys Adjtime(delta *Timeval, olddelta *Timeval) (errno int) |
| //sys Chdir(path string) (errno int) |
| //sys Chflags(path string, flags int) (errno int) |
| //sys Chmod(path string, mode int) (errno int) |
| //sys Chown(path string, uid int, gid int) (errno int) |
| //sys Chroot(path string) (errno int) |
| //sys Close(fd int) (errno int) |
| //sys Dup(fd int) (nfd int, errno int) |
| //sys Dup2(from int, to int) (errno int) |
| //sys Exchangedata(path1 string, path2 string, options int) (errno int) |
| //sys Exit(code int) |
| //sys Fchdir(fd int) (errno int) |
| //sys Fchflags(path string, flags int) (errno int) |
| //sys Fchmod(fd int, mode int) (errno int) |
| //sys Fchown(fd int, uid int, gid int) (errno int) |
| //sys Flock(fd int, how int) (errno int) |
| //sys Fpathconf(fd int, name int) (val int, errno int) |
| //sys Fstat(fd int, stat *Stat_t) (errno int) = SYS_FSTAT64 |
| //sys Fstatfs(fd int, stat *Statfs_t) (errno int) = SYS_FSTATFS64 |
| //sys Fsync(fd int) (errno int) |
| //sys Ftruncate(fd int, length int64) (errno int) |
| //sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, errno int) = SYS_GETDIRENTRIES64 |
| //sys Getdtablesize() (size int) |
| //sys Getegid() (egid int) |
| //sys Geteuid() (uid int) |
| //sys Getfsstat(buf []Statfs_t, flags int) (n int, errno int) = SYS_GETFSSTAT64 |
| //sys Getgid() (gid int) |
| //sys Getpgid(pid int) (pgid int, errno int) |
| //sys Getpgrp() (pgrp int) |
| //sys Getpid() (pid int) |
| //sys Getppid() (ppid int) |
| //sys Getpriority(which int, who int) (prio int, errno int) |
| //sys Getrlimit(which int, lim *Rlimit) (errno int) |
| //sys Getrusage(who int, rusage *Rusage) (errno int) |
| //sys Getsid(pid int) (sid int, errno int) |
| //sys Getuid() (uid int) |
| //sys Issetugid() (tainted bool) |
| //sys Kill(pid int, signum int, posix int) (errno int) |
| //sys Kqueue() (fd int, errno int) |
| //sys Lchown(path string, uid int, gid int) (errno int) |
| //sys Link(path string, link string) (errno int) |
| //sys Listen(s int, backlog int) (errno int) |
| //sys Lstat(path string, stat *Stat_t) (errno int) = SYS_LSTAT64 |
| //sys Mkdir(path string, mode int) (errno int) |
| //sys Mkfifo(path string, mode int) (errno int) |
| //sys Mknod(path string, mode int, dev int) (errno int) |
| //sys Open(path string, mode int, perm int) (fd int, errno int) |
| //sys Pathconf(path string, name int) (val int, errno int) |
| //sys Pread(fd int, p []byte, offset int64) (n int, errno int) |
| //sys Pwrite(fd int, p []byte, offset int64) (n int, errno int) |
| //sys Read(fd int, p []byte) (n int, errno int) |
| //sys Readlink(path string, buf []byte) (n int, errno int) |
| //sys Rename(from string, to string) (errno int) |
| //sys Revoke(path string) (errno int) |
| //sys Rmdir(path string) (errno int) |
| //sys Seek(fd int, offset int64, whence int) (newoffset int64, errno int) = SYS_LSEEK |
| //sys Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (errno int) |
| //sys Setegid(egid int) (errno int) |
| //sys Seteuid(euid int) (errno int) |
| //sys Setgid(gid int) (errno int) |
| //sys Setlogin(name string) (errno int) |
| //sys Setpgid(pid int, pgid int) (errno int) |
| //sys Setpriority(which int, who int, prio int) (errno int) |
| //sys Setprivexec(flag int) (errno int) |
| //sys Setregid(rgid int, egid int) (errno int) |
| //sys Setreuid(ruid int, euid int) (errno int) |
| //sys Setrlimit(which int, lim *Rlimit) (errno int) |
| //sys Setsid() (pid int, errno int) |
| //sys Settimeofday(tp *Timeval) (errno int) |
| //sys Setuid(uid int) (errno int) |
| //sys Stat(path string, stat *Stat_t) (errno int) = SYS_STAT64 |
| //sys Statfs(path string, stat *Statfs_t) (errno int) = SYS_STATFS64 |
| //sys Symlink(path string, link string) (errno int) |
| //sys Sync() (errno int) |
| //sys Truncate(path string, length int64) (errno int) |
| //sys Umask(newmask int) (errno int) |
| //sys Undelete(path string) (errno int) |
| //sys Unlink(path string) (errno int) |
| //sys Unmount(path string, flags int) (errno int) |
| //sys Write(fd int, p []byte) (n int, errno int) |
| //sys read(fd int, buf *byte, nbuf int) (n int, errno int) |
| //sys write(fd int, buf *byte, nbuf int) (n int, errno int) |
| |
| |
| /* |
| * Unimplemented |
| */ |
| // Profil |
| // Sigaction |
| // Sigprocmask |
| // Getlogin |
| // Sigpending |
| // Sigaltstack |
| // Ioctl |
| // Reboot |
| // Execve |
| // Vfork |
| // Sbrk |
| // Sstk |
| // Ovadvise |
| // Mincore |
| // Setitimer |
| // Swapon |
| // Select |
| // Sigsuspend |
| // Readv |
| // Writev |
| // Nfssvc |
| // Getfh |
| // Quotactl |
| // Mount |
| // Csops |
| // Waitid |
| // Add_profil |
| // Kdebug_trace |
| // Sigreturn |
| // Mmap |
| // Mlock |
| // Munlock |
| // Atsocket |
| // Kqueue_from_portset_np |
| // Kqueue_portset |
| // Getattrlist |
| // Setattrlist |
| // Getdirentriesattr |
| // Searchfs |
| // Delete |
| // Copyfile |
| // Poll |
| // Watchevent |
| // Waitevent |
| // Modwatch |
| // Getxattr |
| // Fgetxattr |
| // Setxattr |
| // Fsetxattr |
| // Removexattr |
| // Fremovexattr |
| // Listxattr |
| // Flistxattr |
| // Fsctl |
| // Initgroups |
| // Posix_spawn |
| // Nfsclnt |
| // Fhopen |
| // Minherit |
| // Semsys |
| // Msgsys |
| // Shmsys |
| // Semctl |
| // Semget |
| // Semop |
| // Msgctl |
| // Msgget |
| // Msgsnd |
| // Msgrcv |
| // Shmat |
| // Shmctl |
| // Shmdt |
| // Shmget |
| // Shm_open |
| // Shm_unlink |
| // Sem_open |
| // Sem_close |
| // Sem_unlink |
| // Sem_wait |
| // Sem_trywait |
| // Sem_post |
| // Sem_getvalue |
| // Sem_init |
| // Sem_destroy |
| // Open_extended |
| // Umask_extended |
| // Stat_extended |
| // Lstat_extended |
| // Fstat_extended |
| // Chmod_extended |
| // Fchmod_extended |
| // Access_extended |
| // Settid |
| // Gettid |
| // Setsgroups |
| // Getsgroups |
| // Setwgroups |
| // Getwgroups |
| // Mkfifo_extended |
| // Mkdir_extended |
| // Identitysvc |
| // Shared_region_check_np |
| // Shared_region_map_np |
| // __pthread_mutex_destroy |
| // __pthread_mutex_init |
| // __pthread_mutex_lock |
| // __pthread_mutex_trylock |
| // __pthread_mutex_unlock |
| // __pthread_cond_init |
| // __pthread_cond_destroy |
| // __pthread_cond_broadcast |
| // __pthread_cond_signal |
| // Setsid_with_pid |
| // __pthread_cond_timedwait |
| // Aio_fsync |
| // Aio_return |
| // Aio_suspend |
| // Aio_cancel |
| // Aio_error |
| // Aio_read |
| // Aio_write |
| // Lio_listio |
| // __pthread_cond_wait |
| // Iopolicysys |
| // Mlockall |
| // Munlockall |
| // __pthread_kill |
| // __pthread_sigmask |
| // __sigwait |
| // __disable_threadsignal |
| // __pthread_markcancel |
| // __pthread_canceled |
| // __semwait_signal |
| // Proc_info |
| // Sendfile |
| // Stat64_extended |
| // Lstat64_extended |
| // Fstat64_extended |
| // __pthread_chdir |
| // __pthread_fchdir |
| // Audit |
| // Auditon |
| // Getauid |
| // Setauid |
| // Getaudit |
| // Setaudit |
| // Getaudit_addr |
| // Setaudit_addr |
| // Auditctl |
| // Bsdthread_create |
| // Bsdthread_terminate |
| // Stack_snapshot |
| // Bsdthread_register |
| // Workq_open |
| // Workq_ops |
| // __mac_execve |
| // __mac_syscall |
| // __mac_get_file |
| // __mac_set_file |
| // __mac_get_link |
| // __mac_set_link |
| // __mac_get_proc |
| // __mac_set_proc |
| // __mac_get_fd |
| // __mac_set_fd |
| // __mac_get_pid |
| // __mac_get_lcid |
| // __mac_get_lctx |
| // __mac_set_lctx |
| // Setlcid |
| // Read_nocancel |
| // Write_nocancel |
| // Open_nocancel |
| // Close_nocancel |
| // Wait4_nocancel |
| // Recvmsg_nocancel |
| // Sendmsg_nocancel |
| // Recvfrom_nocancel |
| // Accept_nocancel |
| // Msync_nocancel |
| // Fcntl_nocancel |
| // Select_nocancel |
| // Fsync_nocancel |
| // Connect_nocancel |
| // Sigsuspend_nocancel |
| // Readv_nocancel |
| // Writev_nocancel |
| // Sendto_nocancel |
| // Pread_nocancel |
| // Pwrite_nocancel |
| // Waitid_nocancel |
| // Poll_nocancel |
| // Msgsnd_nocancel |
| // Msgrcv_nocancel |
| // Sem_wait_nocancel |
| // Aio_suspend_nocancel |
| // __sigwait_nocancel |
| // __semwait_signal_nocancel |
| // __mac_mount |
| // __mac_get_mount |
| // __mac_getfsstat |
| |