From: Nicholas Nethercote Date: Sun, 28 Aug 2005 05:10:48 +0000 (+0000) Subject: Save some informative emails about Darwin from Greg Parker. X-Git-Tag: svn/VALGRIND_3_1_0~502 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2a2434f7d98cecb01e8c166c013a588b5143390e;p=thirdparty%2Fvalgrind.git Save some informative emails about Darwin from Greg Parker. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@4547 --- diff --git a/docs/internals/Makefile.am b/docs/internals/Makefile.am index f1bb01f2f4..8268843a14 100644 --- a/docs/internals/Makefile.am +++ b/docs/internals/Makefile.am @@ -1,5 +1,7 @@ EXTRA_DIST = \ - 3_0_BUGSTATUS 64-bit-cleanness.txt directory-structure.txt \ + 3_0_BUGSTATUS 64-bit-cleanness.txt \ + darwin-notes.txt darwin-syscalls.txt \ + directory-structure.txt \ m_replacemalloc.txt \ m_syswrap.txt module-structure.txt notes.txt porting-HOWTO.txt \ porting-to-ARM.txt \ diff --git a/docs/internals/darwin-notes.txt b/docs/internals/darwin-notes.txt new file mode 100644 index 0000000000..6070afc4a6 --- /dev/null +++ b/docs/internals/darwin-notes.txt @@ -0,0 +1,78 @@ +[Julian replying to Greg Parker's notes about darwin/ppc32] + + +> Some notes about porting Valgrind 3.x to Mac OS X / PowerPC: +> +> * Darwin always uses a 64-bit off_t, even on 32-bit architectures. +> (FreeBSD may also do this.) Valgrind currently allows off_t to +> be pointer sized only, but it doesn't look like there is any +> strong dependence on this anywhere. + +Ok. This sounds fairly harmless. + +> * dispatch.S should be platform-specific instead of arch-specific. +> In particular, Darwin's assembler is not GNU as, so the file's +> syntax would be wrong even if everything else were the same. +> It should be reasonable to change dispatch-$VG_ARCH.S to +> dispatch-$VG_OS-$VG_ARCH.S . + +True. + +> * Some Darwin syscalls take 7 arguments (in particular, mmap() +> with 64-bit off_t offset). Valgrind currently provides +> arg1..arg6. I don't see any obvious 8-argument syscalls. +> Do other architectures define a 7th syscall argument and +> just never use it, or do they have a 6 argument max? + +6 args is as many as Linux uses, it seems, and that's why the +m_syswrap abstractions stop at 6. But clearly that could be +extended to 7 with minimal effort. + +> * Darwin syscalls return a full 64-bit result, even on 32-bit +> architectures. In particular, the lseek() syscall returns +> a 64-bit off_t in registers r3 and r4. For syscalls that +> return a 32-bit int, the kernel sets the other return +> register to zero (or the appropriate sign extension for +> signed return types). I don't know how much of an effect +> changing this would have. + +I think the m_syswrap abstractions should be able to hide that OK. + +> * Darwin/PPC syscalls indicate success and failure in an unusual +> way: successful calls and failed calls return to different +> points. A syscall call usually looks like this: +> +> // ...set up parameters here... +> sc // make the syscall +> b BAD // failed calls return here +> GOOD: +> nop // successful calls return here +> // ...handle success case here... +> blr +> BAD: +> // ...handle failure case here... +> blr + +So you're saying that after sc, execution continues either at +CIA+4 or CIA+8 depending on outcome. Right? + +> Handling this in VG_(do_syscall_for_client) isn't too bad. +> One option is to store the PC of the last simulated `sc` +> in the thread state, updating it before each call. Another +> is to store a "sc failed" bit in each thread state, updating +> it after each call. In either case, the simulated PC after +> completion of the simulated `sc` would be adjusted based on +> the result of the real `sc` or the syscall wrapper. The +> syscall restarter would use the extra thread state to decide +> whether to back up on instruction or two. +> +> Handling this in VEX might be more difficult, because VEX +> might need to know that `sc` looks like a conditional branch +> in basic block analysis. + +Probably pretty harmless. There's all sorts of tricks that can +be played. I think it's a non-problem. + +> (Of course, Mach traps use `sc` but don't use the PC-modifying +> calling convention. However, Mach traps are an entirely different +> ball of wax, and much will be said about them later.) diff --git a/docs/internals/darwin-syscalls.txt b/docs/internals/darwin-syscalls.txt new file mode 100644 index 0000000000..2cb7fda776 --- /dev/null +++ b/docs/internals/darwin-syscalls.txt @@ -0,0 +1,479 @@ +[Master list of Darwin syscalls, courtesy of Greg Parker] + + +xnu-792.2.4:bsd/kern/syscalls.master + +; derived from: FreeBSD @(#)syscalls.master 8.2 (Berkeley) 1/13/94 +; +; System call name/number master file. +; This is file processed by .../xnu/bsd/kern/makesyscalls.sh and creates: +; .../xnu/bsd/kern/init_sysent.c +; .../xnu/bsd/kern/syscalls.c +; .../xnu/bsd/sys/syscall.h +; .../xnu/bsd/sys/sysproto.h +; +; Columns -> | Number | Cancel | Funnel | Files | { Name and Args } | { Comments } +; Number: system call number, must be in order +; Cancel: type of thread cancel - "PRE", "POST" or "NONE" +; Funnel: type of funnel - "KERN" or "NONE" +; Files: with files to generate - "ALL" or any combo of: +; "T" for syscall table (in init_sysent.c) +; "N" for syscall names (in syscalls.c) +; "H" for syscall headers (in syscall.h) +; "P" for syscall prototypes (in sysproto.h) +; Comments: additional comments about the sys call copied to output files +; +; #ifdef's, #include's, #if's etc. are copied to all output files. + +#include +#include +#include +#include +#include +#include + +e NONE NONE ALL { int nosys(void); } { indirect syscall } +1 NONE KERN ALL { void exit(int rval); } +2 NONE KERN ALL { int fork(void); } +3 PRE NONE ALL { user_ssize_t read(int fd, user_addr_t cbuf, user_size_t nbyte); } +4 PRE NONE ALL { user_ssize_t write(int fd, user_addr_t cbuf, user_size_t nbyte); } +5 PRE NONE ALL { int open(user_addr_t path, int flags, int mode); } +6 PRE NONE ALL { int close(int fd); } +7 PRE KERN ALL { int wait4(int pid, user_addr_t status, int options, user_addr_t rusage); } +8 NONE NONE ALL { int nosys(void); } { old creat } +9 NONE NONE ALL { int link(user_addr_t path, user_addr_t link); } +10 NONE NONE ALL { int unlink(user_addr_t path); } +11 NONE NONE ALL { int nosys(void); } { old execv } +12 NONE NONE ALL { int chdir(user_addr_t path); } +13 NONE NONE ALL { int fchdir(int fd); } +14 NONE NONE ALL { int mknod(user_addr_t path, int mode, int dev); } +15 NONE NONE ALL { int chmod(user_addr_t path, int mode); } +16 NONE NONE ALL { int chown(user_addr_t path, int uid, int gid); } +17 NONE NONE UALL { int obreak(char *nsize); } { old break } + +#if COMPAT_GETFSSTAT +18 NONE NONE ALL { int ogetfsstat(user_addr_t buf, int bufsize, int flags); } +#else +18 NONE NONE ALL { int getfsstat(user_addr_t buf, int bufsize, int flags); } +#endif + +19 NONE NONE ALL { int nosys(void); } { old lseek } +20 NONE NONE ALL { int getpid(void); } +21 NONE NONE ALL { int nosys(void); } { old mount } +22 NONE NONE ALL { int nosys(void); } { old umount } +23 NONE KERN ALL { int setuid(uid_t uid); } +24 NONE KERN ALL { int getuid(void); } +25 NONE KERN ALL { int geteuid(void); } +26 NONE KERN ALL { int ptrace(int req, pid_t pid, caddr_t addr, int data); } +27 PRE NONE ALL { int recvmsg(int s, struct msghdr *msg, int flags); } +28 PRE NONE ALL { int sendmsg(int s, caddr_t msg, int flags); } +29 PRE NONE ALL { int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, int *fromlenaddr); } +30 PRE NONE ALL { int accept(int s, caddr_t name, socklen_t *anamelen); } +31 NONE NONE ALL { int getpeername(int fdes, caddr_t asa, socklen_t *alen); } +32 NONE NONE ALL { int getsockname(int fdes, caddr_t asa, socklen_t *alen); } +33 NONE NONE ALL { int access(user_addr_t path, int flags); } +34 NONE NONE ALL { int chflags(char *path, int flags); } +35 NONE NONE ALL { int fchflags(int fd, int flags); } +36 NONE NONE ALL { int sync(void); } +37 NONE KERN ALL { int kill(int pid, int signum); } +38 NONE NONE ALL { int nosys(void); } { old stat } +39 NONE KERN ALL { int getppid(void); } +40 NONE NONE ALL { int nosys(void); } { old lstat } +41 NONE NONE ALL { int dup(u_int fd); } +42 NONE NONE ALL { int pipe(void); } +43 NONE KERN ALL { int getegid(void); } +44 NONE KERN ALL { int profil(short *bufbase, size_t bufsize, u_long pcoffset, u_int pcscale); } +45 NONE KERN ALL { int ktrace(const char *fname, int ops, int facs, int pid); } +46 NONE KERN ALL { int sigaction(int signum, struct __sigaction *nsa, struct sigaction *osa); } +47 NONE KERN ALL { int getgid(void); } +48 NONE KERN ALL { int sigprocmask(int how, user_addr_t mask, user_addr_t omask); } +49 NONE KERN ALL { int getlogin(char *namebuf, u_int namelen); } +50 NONE KERN ALL { int setlogin(char *namebuf); } +51 NONE KERN ALL { int acct(char *path); } +52 NONE KERN ALL { int sigpending(struct sigvec *osv); } +53 NONE KERN ALL { int sigaltstack(struct sigaltstack *nss, struct sigaltstack *oss); } +54 NONE NONE ALL { int ioctl(int fd, u_long com, caddr_t data); } +55 NONE KERN ALL { int reboot(int opt, char *command); } +56 NONE NONE ALL { int revoke(char *path); } +57 NONE NONE ALL { int symlink(char *path, char *link); } +58 NONE NONE ALL { int readlink(char *path, char *buf, int count); } +59 NONE KERN ALL { int execve(char *fname, char **argp, char **envp); } +60 NONE KERN ALL { int umask(int newmask); } +61 NONE KERN ALL { int chroot(user_addr_t path); } +62 NONE NONE ALL { int nosys(void); } { old fstat } +63 NONE NONE ALL { int nosys(void); } { used internally, reserved } +64 NONE NONE ALL { int nosys(void); } { old getpagesize } +65 PRE NONE ALL { int msync(caddr_t addr, size_t len, int flags); } +66 NONE KERN ALL { int vfork(void); } +67 NONE NONE ALL { int nosys(void); } { old vread } +68 NONE NONE ALL { int nosys(void); } { old vwrite } +69 NONE NONE ALL { int sbrk(int incr); } +70 NONE NONE ALL { int sstk(int incr); } +71 NONE NONE ALL { int nosys(void); } { old mmap } +72 NONE NONE ALL { int ovadvise(void); } { old vadvise } +73 NONE NONE ALL { int munmap(caddr_t addr, size_t len); } +74 NONE NONE ALL { int mprotect(caddr_t addr, size_t len, int prot); } +75 NONE NONE ALL { int madvise(caddr_t addr, size_t len, int behav); } +76 NONE NONE ALL { int nosys(void); } { old vhangup } +77 NONE NONE ALL { int nosys(void); } { old vlimit } +78 NONE NONE ALL { int mincore(user_addr_t addr, user_size_t len, user_addr_t vec); } +79 NONE KERN ALL { int getgroups(u_int gidsetsize, gid_t *gidset); } +80 NONE KERN ALL { int setgroups(u_int gidsetsize, gid_t *gidset); } +81 NONE KERN ALL { int getpgrp(void); } +82 NONE KERN ALL { int setpgid(int pid, int pgid); } +83 NONE KERN ALL { int setitimer(u_int which, struct itimerval *itv, struct itimerval *oitv); } +84 NONE NONE ALL { int nosys(void); } { old wait } +85 NONE NONE ALL { int swapon(void); } +86 NONE KERN ALL { int getitimer(u_int which, struct itimerval *itv); } +87 NONE NONE ALL { int nosys(void); } { old gethostname } +88 NONE NONE ALL { int nosys(void); } { old sethostname } +89 NONE NONE ALL { int getdtablesize(void); } +90 NONE NONE ALL { int dup2(u_int from, u_int to); } +91 NONE NONE ALL { int nosys(void); } { old getdopt } +92 PRE NONE ALL { int fcntl(int fd, int cmd, long arg); } +93 PRE KERN ALL { int select(int nd, u_int32_t *in, u_int32_t *ou, u_int32_t *ex, struct timeval *tv); } +94 NONE NONE ALL { int nosys(void); } { old setdopt } +95 PRE NONE ALL { int fsync(int fd); } +96 NONE KERN ALL { int setpriority(int which, int who, int prio); } +97 NONE NONE ALL { int socket(int domain, int type, int protocol); } +98 PRE NONE ALL { int connect(int s, caddr_t name, socklen_t namelen); } +99 NONE NONE ALL { int nosys(void); } { old accept } +100 NONE KERN ALL { int getpriority(int which, int who); } +101 NONE NONE ALL { int nosys(void); } { old send } +102 NONE NONE ALL { int nosys(void); } { old recv } + +#ifdef __ppc__ +103 NONE NONE ALL { int nosys(void); } { old sigreturn } +#else +103 NONE KERN UALL { int sigreturn(struct sigcontext *sigcntxp); } +#endif + +104 NONE NONE ALL { int bind(int s, caddr_t name, socklen_t namelen); } +105 NONE NONE ALL { int setsockopt(int s, int level, int name, caddr_t val, socklen_t valsize); } +106 NONE NONE ALL { int listen(int s, int backlog); } +107 NONE NONE ALL { int nosys(void); } { old vtimes } +108 NONE NONE ALL { int nosys(void); } { old sigvec } +109 NONE NONE ALL { int nosys(void); } { old sigblock } +110 NONE NONE ALL { int nosys(void); } { old sigsetmask } +111 PRE KERN ALL { int sigsuspend(sigset_t mask); } +112 NONE NONE ALL { int nosys(void); } { old sigstack } +113 NONE NONE ALL { int nosys(void); } { old recvmsg } +114 NONE NONE ALL { int nosys(void); } { old sendmsg } +115 NONE NONE ALL { int nosys(void); } { old vtrace } + +#ifdef __ppc__ +116 NONE NONE ALL { int ppc_gettimeofday(struct timeval *tp, struct timezone *tzp); } +#else +116 NONE NONE ALL { int gettimeofday(struct timeval *tp, struct timezone *tzp); } +#endif + +117 NONE KERN ALL { int getrusage(int who, struct rusage *rusage); } +118 NONE NONE ALL { int getsockopt(int s, int level, int name, caddr_t val, socklen_t *avalsize); } +119 NONE NONE ALL { int nosys(void); } { old resuba } +120 PRE NONE ALL { user_ssize_t readv(int fd, struct iovec *iovp, u_int iovcnt); } +121 PRE NONE ALL { user_ssize_t writev(int fd, struct iovec *iovp, u_int iovcnt); } +122 NONE KERN ALL { int settimeofday(struct timeval *tv, struct timezone *tzp); } +123 NONE NONE ALL { int fchown(int fd, int uid, int gid); } +124 NONE NONE ALL { int fchmod(int fd, int mode); } +125 NONE NONE ALL { int nosys(void); } { old recvfrom } +126 NONE NONE ALL { int nosys(void); } { old setreuid } +127 NONE NONE ALL { int nosys(void); } { old setregid } +128 NONE NONE ALL { int rename(char *from, char *to); } +129 NONE NONE ALL { int nosys(void); } { old truncate } +130 NONE NONE ALL { int nosys(void); } { old ftruncate } +131 NONE NONE ALL { int flock(int fd, int how); } +132 NONE NONE ALL { int mkfifo(user_addr_t path, int mode); } +133 PRE NONE ALL { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, socklen_t tolen); } +134 NONE NONE ALL { int shutdown(int s, int how); } +135 NONE NONE ALL { int socketpair(int domain, int type, int protocol, int *rsv); } +136 NONE NONE ALL { int mkdir(user_addr_t path, int mode); } +137 NONE NONE ALL { int rmdir(char *path); } +138 NONE NONE ALL { int utimes(char *path, struct timeval *tptr); } +139 NONE NONE ALL { int futimes(int fd, struct timeval *tptr); } +140 NONE KERN ALL { int adjtime(struct timeval *delta, struct timeval *olddelta); } +141 NONE NONE ALL { int nosys(void); } { old getpeername } +142 NONE NONE ALL { int nosys(void); } { old gethostid } +143 NONE NONE ALL { int nosys(void); } { old sethostid } +144 NONE NONE ALL { int nosys(void); } { old getrlimit } +145 NONE NONE ALL { int nosys(void); } { old setrlimit } +146 NONE NONE ALL { int nosys(void); } { old killpg } +147 NONE KERN ALL { int setsid(void); } +148 NONE NONE ALL { int nosys(void); } { old setquota } +149 NONE NONE ALL { int nosys(void); } { old qquota } +150 NONE NONE ALL { int nosys(void); } { old getsockname } +151 NONE KERN ALL { int getpgid(pid_t pid); } +152 NONE KERN ALL { int setprivexec(int flag); } +153 PRE NONE ALL { user_ssize_t pread(int fd, user_addr_t buf, user_size_t nbyte, off_t offset); } +154 PRE NONE ALL { user_ssize_t pwrite(int fd, user_addr_t buf, user_size_t nbyte, off_t offset); } + +#if NFSSERVER +155 NONE KERN ALL { int nfssvc(int flag, caddr_t argp); } +#else +155 NONE NONE ALL { int nosys(void); } +#endif + +156 NONE NONE ALL { int nosys(void); } { old getdirentries } +157 NONE NONE ALL { int statfs(char *path, struct statfs *buf); } +158 NONE NONE ALL { int fstatfs(int fd, struct statfs *buf); } +159 NONE NONE ALL { int unmount(user_addr_t path, int flags); } +160 NONE NONE ALL { int nosys(void); } { old async_daemon } + +#if NFSCLIENT +161 NONE KERN ALL { int getfh(char *fname, fhandle_t *fhp); } +#else +161 NONE NONE ALL { int nosys(void); } +#endif + +162 NONE NONE ALL { int nosys(void); } { old getdomainname } +163 NONE NONE ALL { int nosys(void); } { old setdomainname } +164 NONE NONE ALL { int nosys(void); } +165 NONE KERN ALL { int quotactl(char *path, int cmd, int uid, caddr_t arg); } +166 NONE NONE ALL { int nosys(void); } { old exportfs } +167 NONE NONE ALL { int mount(char *type, char *path, int flags, caddr_t data); } +168 NONE NONE ALL { int nosys(void); } { old ustat } +169 NONE NONE ALL { int nosys(void); } +170 NONE NONE HN { int table(void); } { old table } +171 NONE NONE ALL { int nosys(void); } { old wait3 } +172 NONE NONE ALL { int nosys(void); } { old rpause } +173 PRE KERN ALL { int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options); } +174 NONE NONE ALL { int nosys(void); } { old getdents } +175 NONE NONE ALL { int nosys(void); } { old gc_control } +176 NONE KERN ALL { int add_profil(short *bufbase, size_t bufsize, u_long pcoffset, u_int pcscale); } +177 NONE NONE ALL { int nosys(void); } +178 NONE NONE ALL { int nosys(void); } +179 NONE NONE ALL { int nosys(void); } +180 NONE NONE UALL { int kdebug_trace(int code, int arg1, int arg2, int arg3, int arg4, int arg5); } +181 NONE KERN ALL { int setgid(gid_t gid); } +182 NONE KERN ALL { int setegid(gid_t egid); } +183 NONE KERN ALL { int seteuid(uid_t euid); } + +#ifdef __ppc__ +184 NONE KERN ALL { int sigreturn(struct ucontext *uctx, int infostyle); } +#else +184 NONE NONE ALL { int nosys(void); } +#endif + +185 NONE NONE ALL { int nosys(void); } +186 NONE NONE ALL { int nosys(void); } +187 NONE NONE ALL { int nosys(void); } +188 NONE NONE ALL { int stat(user_addr_t path, user_addr_t ub); } +189 NONE NONE ALL { int fstat(int fd, user_addr_t ub); } +190 NONE NONE ALL { int lstat(user_addr_t path, user_addr_t ub); } +191 NONE NONE ALL { int pathconf(char *path, int name); } +192 NONE NONE ALL { int fpathconf(int fd, int name); } + +#if COMPAT_GETFSSTAT +193 NONE NONE ALL { int getfsstat(user_addr_t buf, user_long_t bufsize, int flags); } +#else +193 NONE NONE ALL { int nosys(void); } +#endif + +194 NONE KERN ALL { int getrlimit(u_int which, struct rlimit *rlp); } +195 NONE KERN ALL { int setrlimit(u_int which, struct rlimit *rlp); } +196 NONE NONE ALL { int getdirentries(int fd, char *buf, u_int count, long *basep); } +197 NONE NONE ALL { user_addr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos); } +198 NONE NONE ALL { int nosys(void); } { __syscall } +199 NONE NONE ALL { off_t lseek(int fd, off_t offset, int whence); } +200 NONE NONE ALL { int truncate(char *path, off_t length); } +201 NONE NONE ALL { int ftruncate(int fd, off_t length); } +202 NONE KERN ALL { int __sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen); } +203 NONE NONE ALL { int mlock(caddr_t addr, size_t len); } +204 NONE NONE ALL { int munlock(caddr_t addr, size_t len); } +205 NONE NONE ALL { int undelete(user_addr_t path); } + +#ifdef __ppc__ +206 NONE NONE ALL { int ATsocket(int proto); } +207 NONE NONE UALL { int ATgetmsg(int fd, void *ctlptr, void *datptr, int *flags); } +208 NONE NONE UALL { int ATputmsg(int fd, void *ctlptr, void *datptr, int flags); } +209 NONE NONE UALL { int ATPsndreq(int fd, unsigned char *buf, int len, int nowait); } +210 NONE NONE UALL { int ATPsndrsp(int fd, unsigned char *respbuff, int resplen, int datalen); } +211 NONE NONE UALL { int ATPgetreq(int fd, unsigned char *buf, int buflen); } +212 NONE NONE UALL { int ATPgetrsp(int fd, unsigned char *bdsp); } +213 NONE NONE ALL { int nosys(void); } { Reserved for AppleTalk } +#else +206 NONE NONE HN { int ATsocket(int proto); } +207 NONE NONE UHN { int ATgetmsg(int fd, void *ctlptr, void *datptr, int *flags); } +208 NONE NONE UHN { int ATputmsg(int fd, void *ctlptr, void *datptr, int flags); } +209 NONE NONE UHN { int ATPsndreq(int fd, unsigned char *buf, int len, int nowait); } +210 NONE NONE UHN { int ATPsndrsp(int fd, unsigned char *respbuff, int resplen, int datalen); } +211 NONE NONE UHN { int ATPgetreq(int fd, unsigned char *buf, int buflen); } +212 NONE NONE UHN { int ATPgetrsp(int fd, unsigned char *bdsp); } +213 NONE NONE ALL { int nosys(void); } { Reserved for AppleTalk } +#endif /* __ppc__ */ + +214 NONE KERN ALL { int kqueue_from_portset_np(int portset); } +215 NONE KERN ALL { int kqueue_portset_np(int fd); } + +; System Calls 216 - 230 are reserved for calls to support HFS/HFS Plus +; file system semantics. Currently, we only use 215-227. The rest is +; for future expansion in anticipation of new MacOS APIs for HFS Plus. +; These calls are not conditionalized becuase while they are specific +; to HFS semantics, they are not specific to the HFS filesystem. +; We expect all filesystems to recognize the call and report that it is +; not supported or to actually implement it. +216 NONE NONE UHN { int mkcomplex(const char *path, mode_t mode, u_long type); } { soon to be obsolete } +217 NONE NONE UHN { int statv(const char *path, struct vstat *vsb); } { soon to be obsolete } +218 NONE NONE UHN { int lstatv(const char *path, struct vstat *vsb); } { soon to be obsolete } +219 NONE NONE UHN { int fstatv(int fd, struct vstat *vsb); } { soon to be obsolete } +220 NONE NONE ALL { int getattrlist(const char *path, struct attrlist *alist, void *attributeBuffer, size_t bufferSize, u_long options); } +221 NONE NONE ALL { int setattrlist(const char *path, struct attrlist *alist, void *attributeBuffer, size_t bufferSize, u_long options); } +222 NONE NONE ALL { int getdirentriesattr(int fd, struct attrlist *alist, void *buffer, size_t buffersize, u_long *count, u_long *basep, u_long *newstate, u_long options); } +223 NONE NONE ALL { int exchangedata(const char *path1, const char *path2, u_long options); } + +#ifdef __APPLE_API_OBSOLETE +224 NONE NONE UALL { int checkuseraccess(const char *path, uid_t userid, gid_t *groups, int ngroups, int accessrequired, u_long options); } +#else +224 NONE NONE ALL { int nosys(void); } { HFS checkuseraccess check access to a file } +#endif /* __APPLE_API_OBSOLETE */ +225 NONE KERN ALL { int searchfs(const char *path, struct fssearchblock *searchblock, u_long *nummatches, u_long scriptcode, u_long options, struct searchstate *state); } +226 NONE NONE ALL { int delete(user_addr_t path); } { private delete (Carbon semantics) } +227 NONE NONE ALL { int copyfile(char *from, char *to, int mode, int flags); } +228 NONE NONE ALL { int nosys(void); } +229 NONE NONE ALL { int nosys(void); } +230 PRE NONE ALL { int poll(struct pollfd *fds, u_int nfds, int timeout); } +231 NONE NONE UALL { int watchevent(struct eventreq *u_req, int u_eventmask); } +232 NONE NONE UALL { int waitevent(struct eventreq *u_req, struct timeval *tv); } +233 NONE NONE UALL { int modwatch(struct eventreq *u_req, int u_eventmask); } +234 NONE NONE ALL { user_ssize_t getxattr(user_addr_t path, user_addr_t attrname, user_addr_t value, size_t size, uint32_t position, int options); } +235 NONE NONE ALL { user_ssize_t fgetxattr(int fd, user_addr_t attrname, user_addr_t value, size_t size, uint32_t position, int options); } +236 NONE NONE ALL { int setxattr(user_addr_t path, user_addr_t attrname, user_addr_t value, size_t size, uint32_t position, int options); } +237 NONE NONE ALL { int fsetxattr(int fd, user_addr_t attrname, user_addr_t value, size_t size, uint32_t position, int options); } +238 NONE NONE ALL { int removexattr(user_addr_t path, user_addr_t attrname, int options); } +239 NONE NONE ALL { int fremovexattr(int fd, user_addr_t attrname, int options); } +240 NONE NONE ALL { user_ssize_t listxattr(user_addr_t path, user_addr_t namebuf, size_t bufsize, int options); } +241 NONE NONE ALL { user_ssize_t flistxattr(int fd, user_addr_t namebuf, size_t bufsize, int options); } +242 NONE KERN ALL { int fsctl(const char *path, u_long cmd, caddr_t data, u_long options); } +243 NONE KERN ALL { int initgroups(u_int gidsetsize, gid_t *gidset, int gmuid); } +244 NONE NONE ALL { int nosys(void); } +245 NONE NONE ALL { int nosys(void); } +246 NONE NONE ALL { int nosys(void); } + +#if NFSCLIENT +247 NONE KERN ALL { int nfsclnt(int flag, caddr_t argp); } +248 NONE KERN ALL { int fhopen(const struct fhandle *u_fhp, int flags); } +#else +247 NONE NONE ALL { int nosys(void); } +248 NONE NONE ALL { int nosys(void); } +#endif + +249 NONE NONE ALL { int nosys(void); } +250 NONE NONE ALL { int minherit(void *addr, size_t len, int inherit); } +251 NONE NONE ALL { int semsys(u_int which, int a2, int a3, int a4, int a5); } +252 NONE NONE ALL { int msgsys(u_int which, int a2, int a3, int a4, int a5); } +253 NONE NONE ALL { int shmsys(u_int which, int a2, int a3, int a4); } +254 NONE NONE ALL { int semctl(int semid, int semnum, int cmd, semun_t arg); } +255 NONE NONE ALL { int semget(key_t key, int nsems, int semflg); } +256 NONE NONE ALL { int semop(int semid, struct sembuf *sops, int nsops); } +257 NONE NONE ALL { int semconfig(semconfig_ctl_t flag); } +258 NONE NONE ALL { int msgctl(int msqid, int cmd, struct msqid_ds *buf); } +259 NONE NONE ALL { int msgget(key_t key, int msgflg); } +260 PRE NONE ALL { int msgsnd(int msqid, void *msgp, size_t msgsz, int msgflg); } +261 PRE NONE ALL { user_ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); } +262 NONE NONE ALL { int shmat(int shmid, void *shmaddr, int shmflg); } +263 NONE NONE ALL { int shmctl(int shmid, int cmd, struct shmid_ds *buf); } +264 NONE NONE ALL { int shmdt(void *shmaddr); } +265 NONE NONE ALL { int shmget(key_t key, size_t size, int shmflg); } +266 NONE NONE ALL { int shm_open(const char *name, int oflag, int mode); } +267 NONE NONE ALL { int shm_unlink(const char *name); } +268 NONE NONE ALL { user_addr_t sem_open(const char *name, int oflag, int mode, int value); } +269 NONE NONE ALL { int sem_close(sem_t *sem); } +270 NONE NONE ALL { int sem_unlink(const char *name); } +271 PRE NONE ALL { int sem_wait(sem_t *sem); } +272 NONE NONE ALL { int sem_trywait(sem_t *sem); } +273 NONE NONE ALL { int sem_post(sem_t *sem); } +274 NONE NONE ALL { int sem_getvalue(sem_t *sem, int *sval); } +275 NONE NONE ALL { int sem_init(sem_t *sem, int phsared, u_int value); } +276 NONE NONE ALL { int sem_destroy(sem_t *sem); } +277 NONE NONE ALL { int open_extended(user_addr_t path, int flags, uid_t uid, gid_t gid, int mode, user_addr_t xsecurity); } +278 NONE KERN ALL { int umask_extended(int newmask, user_addr_t xsecurity); } +279 NONE NONE ALL { int stat_extended(user_addr_t path, user_addr_t ub, user_addr_t xsecurity, user_addr_t xsecurity_size); } +280 NONE NONE ALL { int lstat_extended(user_addr_t path, user_addr_t ub, user_addr_t xsecurity, user_addr_t xsecurity_size); } +281 NONE NONE ALL { int fstat_extended(int fd, user_addr_t ub, user_addr_t xsecurity, user_addr_t xsecurity_size); } +282 NONE NONE ALL { int chmod_extended(user_addr_t path, uid_t uid, gid_t gid, int mode, user_addr_t xsecurity); } +283 NONE NONE ALL { int fchmod_extended(int fd, uid_t uid, gid_t gid, int mode, user_addr_t xsecurity); } +284 NONE NONE ALL { int access_extended(user_addr_t entries, size_t size, user_addr_t results, uid_t uid); } +285 NONE NONE ALL { int settid(uid_t uid, gid_t gid); } +286 NONE NONE ALL { int gettid(uid_t *uidp, gid_t *gidp); } +287 NONE NONE ALL { int setsgroups(int setlen, user_addr_t guidset); } +288 NONE NONE ALL { int getsgroups(user_addr_t setlen, user_addr_t guidset); } +289 NONE NONE ALL { int setwgroups(int setlen, user_addr_t guidset); } +290 NONE NONE ALL { int getwgroups(user_addr_t setlen, user_addr_t guidset); } +291 NONE NONE ALL { int mkfifo_extended(user_addr_t path, uid_t uid, gid_t gid, int mode, user_addr_t xsecurity); } +292 NONE NONE ALL { int mkdir_extended(user_addr_t path, uid_t uid, gid_t gid, int mode, user_addr_t xsecurity); } +293 NONE NONE ALL { int identitysvc(int opcode, user_addr_t message); } +294 NONE NONE ALL { int nosys(void); } +295 NONE NONE ALL { int nosys(void); } +296 NONE KERN UALL { int load_shared_file(char *filename, caddr_t mfa, u_long mfs, caddr_t *ba, int map_cnt, sf_mapping_t *mappings, int *flags); } +297 NONE KERN UALL { int reset_shared_file(caddr_t *ba, int map_cnt, sf_mapping_t *mappings); } +298 NONE KERN ALL { int new_system_shared_regions(void); } +299 NONE KERN UALL { int shared_region_map_file_np(int fd, uint32_t mappingCount, user_addr_t mappings, user_addr_t slide_p); } +300 NONE KERN UALL { int shared_region_make_private_np(uint32_t rangeCount, user_addr_t ranges); } +301 NONE NONE ALL { int nosys(void); } +302 NONE NONE ALL { int nosys(void); } +303 NONE NONE ALL { int nosys(void); } +304 NONE NONE ALL { int nosys(void); } +305 NONE NONE ALL { int nosys(void); } +306 NONE NONE ALL { int nosys(void); } +307 NONE NONE ALL { int nosys(void); } +308 NONE NONE ALL { int nosys(void); } +309 NONE NONE ALL { int nosys(void); } +310 NONE KERN ALL { int getsid(pid_t pid); } +311 NONE NONE ALL { int settid_with_pid(pid_t pid, int assume); } +312 NONE NONE ALL { int nosys(void); } +313 NONE NONE ALL { int aio_fsync(int op, user_addr_t aiocbp); } +314 NONE NONE ALL { user_ssize_t aio_return(user_addr_t aiocbp); } +315 PRE NONE ALL { int aio_suspend(user_addr_t aiocblist, int nent, user_addr_t timeoutp); } +316 NONE NONE ALL { int aio_cancel(int fd, user_addr_t aiocbp); } +317 NONE NONE ALL { int aio_error(user_addr_t aiocbp); } +318 NONE NONE ALL { int aio_read(user_addr_t aiocbp); } +319 NONE NONE ALL { int aio_write(user_addr_t aiocbp); } +320 NONE NONE ALL { int lio_listio(int mode, user_addr_t aiocblist, int nent, user_addr_t sigp); } +321 NONE NONE ALL { int nosys(void); } +322 NONE NONE ALL { int nosys(void); } +323 NONE NONE ALL { int nosys(void); } +324 NONE NONE ALL { int mlockall(int how); } +325 NONE NONE ALL { int munlockall(int how); } +326 NONE NONE ALL { int nosys(void); } +327 NONE KERN ALL { int issetugid(void); } +328 NONE KERN ALL { int __pthread_kill(int thread_port, int sig); } +329 NONE KERN ALL { int pthread_sigmask(int how, user_addr_t set, user_addr_t oset); } +330 PRE KERN ALL { int sigwait(user_addr_t set, user_addr_t sig); } +331 NONE KERN ALL { int __disable_threadsignal(int value); } +332 NONE NONE ALL { int __pthread_markcancel(int thread_port); } +333 NONE NONE ALL { int __pthread_canceled(int action); } +334 POST NONE ALL { int __semwait_signal(int cond_sem, int mutex_sem, int timeout, int relative, time_t tv_sec, int32_t tv_nsec); } +335 NONE KERN ALL { int utrace(const void *addr, size_t len); } +336 NONE NONE ALL { int nosys(void); } +337 NONE NONE ALL { int nosys(void); } +338 NONE NONE ALL { int nosys(void); } +339 NONE NONE ALL { int nosys(void); } +340 NONE NONE ALL { int nosys(void); } +341 NONE NONE ALL { int nosys(void); } +342 NONE NONE ALL { int nosys(void); } +343 NONE NONE ALL { int nosys(void); } +344 NONE NONE ALL { int nosys(void); } +345 NONE NONE ALL { int nosys(void); } +346 NONE NONE ALL { int nosys(void); } +347 NONE NONE ALL { int nosys(void); } +348 NONE NONE ALL { int nosys(void); } +349 NONE NONE ALL { int nosys(void); } +350 NONE KERN ALL { int audit(void *record, int length); } +351 NONE KERN ALL { int auditon(int cmd, void *data, int length); } +352 NONE KERN ALL { int nosys(void); } +353 NONE KERN ALL { int getauid(au_id_t *auid); } +354 NONE KERN ALL { int setauid(au_id_t *auid); } +355 NONE KERN ALL { int getaudit(struct auditinfo *auditinfo); } +356 NONE KERN ALL { int setaudit(struct auditinfo *auditinfo); } +357 NONE KERN ALL { int getaudit_addr(struct auditinfo_addr *auditinfo_addr, int length); } +358 NONE KERN ALL { int setaudit_addr(struct auditinfo_addr *auditinfo_addr, int length); } +359 NONE KERN ALL { int auditctl(char *path); } +360 NONE NONE ALL { int nosys(void); } +361 NONE NONE ALL { int nosys(void); } +362 NONE NONE ALL { int kqueue(void); } +363 NONE NONE ALL { int kevent(int fd, const struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, const struct timespec *timeout); } +364 NONE NONE ALL { int lchown(user_addr_t path, uid_t owner, gid_t group); } +365 NONE NONE ALL { int nosys(void); } +366 NONE NONE ALL { int nosys(void); } +367 NONE NONE ALL { int nosys(void); } +368 NONE NONE ALL { int nosys(void); } +369 NONE NONE ALL { int nosys(void); }