Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/kern/syscalls.master
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 $FreeBSD$ 2 ; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94 3 ; 4 ; System call name/number master file. 5 ; Processed to created init_sysent.c, syscalls.c and syscall.h. 6 7 ; Columns: number [M]type nargs name alt{name,tag,rtyp}/comments 8 ; number system call number, must be in order 9 ; type one of [M]STD, [M]OBSOL, [M]UNIMPL, [M]COMPAT, [M]CPT_NOA, 10 ; [M]LIBCOMPAT, [M]NODEF, [M]NOARGS, [M]NOPROTO, [M]NOIMPL, 11 ; [M]NOSTD, [M]COMPAT4 12 ; name psuedo-prototype of syscall routine 13 ; If one of the following alts is different, then all appear: 14 ; altname name of system call if different 15 ; alttag name of args struct tag if different from [o]`name'"_args" 16 ; altrtyp return type if not int (bogus - syscalls always return int) 17 ; for UNIMPL/OBSOL, name continues with comments 18 19 ; types: 20 ; [M] e.g. like MSTD -- means the system call is MP-safe. If no 21 ; M prefix is used, the syscall wrapper will obtain the Giant 22 ; lock for the syscall. 23 ; STD always included 24 ; COMPAT included on COMPAT #ifdef 25 ; COMPAT4 included on COMPAT4 #ifdef (FreeBSD 4 compat) 26 ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h 27 ; OBSOL obsolete, not included in system, only specifies name 28 ; UNIMPL not implemented, placeholder only 29 ; NOSTD implemented but as a lkm that can be statically 30 ; compiled in sysent entry will be filled with lkmsys 31 ; so the SYSCALL_MODULE macro works 32 ; 33 ; Please copy any additions and changes to the following compatability tables: 34 ; sys/compat/freebsd32/syscalls.master 35 36 ; #ifdef's, etc. may be included, and are copied to the output files. 37 38 #include <sys/param.h> 39 #include <sys/sysent.h> 40 #include <sys/sysproto.h> 41 42 ; Reserved/unimplemented system calls in the range 0-150 inclusive 43 ; are reserved for use in future Berkeley releases. 44 ; Additional system calls implemented in vendor and other 45 ; redistributions should be placed in the reserved range at the end 46 ; of the current calls. 47 48 0 MSTD { int nosys(void); } syscall nosys_args int 49 1 MSTD { void sys_exit(int rval); } exit sys_exit_args void 50 2 MSTD { int fork(void); } 51 3 MSTD { ssize_t read(int fd, void *buf, size_t nbyte); } 52 4 MSTD { ssize_t write(int fd, const void *buf, size_t nbyte); } 53 5 MSTD { int open(char *path, int flags, int mode); } 54 ; XXX should be { int open(const char *path, int flags, ...); } 55 ; but we're not ready for `const' or varargs. 56 ; XXX man page says `mode_t mode'. 57 6 MSTD { int close(int fd); } 58 7 MSTD { int wait4(int pid, int *status, int options, \ 59 struct rusage *rusage); } wait4 wait_args int 60 8 MCOMPAT { int creat(char *path, int mode); } 61 9 MSTD { int link(char *path, char *link); } 62 10 MSTD { int unlink(char *path); } 63 11 OBSOL execv 64 12 STD { int chdir(char *path); } 65 13 STD { int fchdir(int fd); } 66 14 STD { int mknod(char *path, int mode, int dev); } 67 15 STD { int chmod(char *path, int mode); } 68 16 STD { int chown(char *path, int uid, int gid); } 69 17 MSTD { int obreak(char *nsize); } break obreak_args int 70 18 COMPAT4 { int getfsstat(struct ostatfs *buf, long bufsize, int flags); } 71 19 COMPAT { long lseek(int fd, long offset, int whence); } 72 20 MSTD { pid_t getpid(void); } 73 21 STD { int mount(char *type, char *path, int flags, caddr_t data); } 74 ; XXX `path' should have type `const char *' but we're not ready for that. 75 22 STD { int unmount(char *path, int flags); } 76 23 MSTD { int setuid(uid_t uid); } 77 24 MSTD { uid_t getuid(void); } 78 25 MSTD { uid_t geteuid(void); } 79 26 MSTD { int ptrace(int req, pid_t pid, caddr_t addr, int data); } 80 27 MSTD { int recvmsg(int s, struct msghdr *msg, int flags); } 81 28 MSTD { int sendmsg(int s, struct msghdr *msg, int flags); } 82 29 MSTD { int recvfrom(int s, caddr_t buf, size_t len, int flags, \ 83 struct sockaddr * __restrict from, \ 84 __socklen_t * __restrict fromlenaddr); } 85 30 MSTD { int accept(int s, struct sockaddr * __restrict name, \ 86 __socklen_t * __restrict anamelen); } 87 31 MSTD { int getpeername(int fdes, struct sockaddr * __restrict asa, \ 88 __socklen_t * __restrict alen); } 89 32 MSTD { int getsockname(int fdes, struct sockaddr * __restrict asa, \ 90 __socklen_t * __restrict alen); } 91 33 STD { int access(char *path, int flags); } 92 34 STD { int chflags(char *path, int flags); } 93 35 STD { int fchflags(int fd, int flags); } 94 36 STD { int sync(void); } 95 37 MSTD { int kill(int pid, int signum); } 96 38 COMPAT { int stat(char *path, struct ostat *ub); } 97 39 MSTD { pid_t getppid(void); } 98 40 COMPAT { int lstat(char *path, struct ostat *ub); } 99 41 MSTD { int dup(u_int fd); } 100 42 MSTD { int pipe(void); } 101 43 MSTD { gid_t getegid(void); } 102 44 MSTD { int profil(caddr_t samples, size_t size, size_t offset, \ 103 u_int scale); } 104 45 MSTD { int ktrace(const char *fname, int ops, int facs, int pid); } 105 46 MCOMPAT { int sigaction(int signum, struct osigaction *nsa, \ 106 struct osigaction *osa); } 107 47 MSTD { gid_t getgid(void); } 108 48 MCOMPAT { int sigprocmask(int how, osigset_t mask); } 109 ; XXX note nonstandard (bogus) calling convention - the libc stub passes 110 ; us the mask, not a pointer to it, and we return the old mask as the 111 ; (int) return value. 112 49 MSTD { int getlogin(char *namebuf, u_int namelen); } 113 50 MSTD { int setlogin(char *namebuf); } 114 51 MSTD { int acct(char *path); } 115 52 MCOMPAT { int sigpending(void); } 116 53 MSTD { int sigaltstack(stack_t *ss, stack_t *oss); } 117 54 MSTD { int ioctl(int fd, u_long com, caddr_t data); } 118 55 MSTD { int reboot(int opt); } 119 56 STD { int revoke(char *path); } 120 57 STD { int symlink(char *path, char *link); } 121 58 STD { int readlink(char *path, char *buf, int count); } 122 59 MSTD { int execve(char *fname, char **argv, char **envv); } 123 60 MSTD { int umask(int newmask); } umask umask_args int 124 61 STD { int chroot(char *path); } 125 62 MCOMPAT { int fstat(int fd, struct ostat *sb); } 126 63 MCOMPAT { int getkerninfo(int op, char *where, size_t *size, \ 127 int arg); } getkerninfo getkerninfo_args int 128 64 MCOMPAT { int getpagesize(void); } getpagesize getpagesize_args int 129 65 MSTD { int msync(void *addr, size_t len, int flags); } 130 66 MSTD { int vfork(void); } 131 67 OBSOL vread 132 68 OBSOL vwrite 133 69 MSTD { int sbrk(int incr); } 134 70 MSTD { int sstk(int incr); } 135 71 MCOMPAT { int mmap(void *addr, int len, int prot, int flags, int fd, \ 136 long pos); } 137 72 MSTD { int ovadvise(int anom); } vadvise ovadvise_args int 138 73 MSTD { int munmap(void *addr, size_t len); } 139 74 MSTD { int mprotect(const void *addr, size_t len, int prot); } 140 75 MSTD { int madvise(void *addr, size_t len, int behav); } 141 76 OBSOL vhangup 142 77 OBSOL vlimit 143 78 MSTD { int mincore(const void *addr, size_t len, char *vec); } 144 79 MSTD { int getgroups(u_int gidsetsize, gid_t *gidset); } 145 80 MSTD { int setgroups(u_int gidsetsize, gid_t *gidset); } 146 81 MSTD { int getpgrp(void); } 147 82 MSTD { int setpgid(int pid, int pgid); } 148 83 MSTD { int setitimer(u_int which, struct itimerval *itv, \ 149 struct itimerval *oitv); } 150 84 MCOMPAT { int wait(void); } 151 85 MSTD { int swapon(char *name); } 152 86 MSTD { int getitimer(u_int which, struct itimerval *itv); } 153 87 MCOMPAT { int gethostname(char *hostname, u_int len); } \ 154 gethostname gethostname_args int 155 88 MCOMPAT { int sethostname(char *hostname, u_int len); } \ 156 sethostname sethostname_args int 157 89 MSTD { int getdtablesize(void); } 158 90 MSTD { int dup2(u_int from, u_int to); } 159 91 UNIMPL getdopt 160 92 MSTD { int fcntl(int fd, int cmd, long arg); } 161 ; XXX should be { int fcntl(int fd, int cmd, ...); } 162 ; but we're not ready for varargs. 163 93 MSTD { int select(int nd, fd_set *in, fd_set *ou, \ 164 fd_set *ex, struct timeval *tv); } 165 94 UNIMPL setdopt 166 95 STD { int fsync(int fd); } 167 96 MSTD { int setpriority(int which, int who, int prio); } 168 97 MSTD { int socket(int domain, int type, int protocol); } 169 98 MSTD { int connect(int s, caddr_t name, int namelen); } 170 99 MCPT_NOA { int accept(int s, caddr_t name, int *anamelen); } \ 171 accept accept_args int 172 100 MSTD { int getpriority(int which, int who); } 173 101 MCOMPAT { int send(int s, caddr_t buf, int len, int flags); } 174 102 MCOMPAT { int recv(int s, caddr_t buf, int len, int flags); } 175 103 MCOMPAT { int sigreturn(struct osigcontext *sigcntxp); } 176 104 MSTD { int bind(int s, caddr_t name, int namelen); } 177 105 MSTD { int setsockopt(int s, int level, int name, caddr_t val, \ 178 int valsize); } 179 106 MSTD { int listen(int s, int backlog); } 180 107 OBSOL vtimes 181 108 MCOMPAT { int sigvec(int signum, struct sigvec *nsv, \ 182 struct sigvec *osv); } 183 109 MCOMPAT { int sigblock(int mask); } 184 110 MCOMPAT { int sigsetmask(int mask); } 185 111 MCOMPAT { int sigsuspend(osigset_t mask); } 186 ; XXX note nonstandard (bogus) calling convention - the libc stub passes 187 ; us the mask, not a pointer to it. 188 112 MCOMPAT { int sigstack(struct sigstack *nss, struct sigstack *oss); } 189 113 MCOMPAT { int recvmsg(int s, struct omsghdr *msg, int flags); } 190 114 MCOMPAT { int sendmsg(int s, caddr_t msg, int flags); } 191 115 OBSOL vtrace 192 116 MSTD { int gettimeofday(struct timeval *tp, struct timezone *tzp); } 193 117 MSTD { int getrusage(int who, struct rusage *rusage); } 194 118 MSTD { int getsockopt(int s, int level, int name, caddr_t val, \ 195 int *avalsize); } 196 119 UNIMPL resuba (BSD/OS 2.x) 197 120 MSTD { int readv(int fd, struct iovec *iovp, u_int iovcnt); } 198 121 MSTD { int writev(int fd, struct iovec *iovp, u_int iovcnt); } 199 122 MSTD { int settimeofday(struct timeval *tv, struct timezone *tzp); } 200 123 STD { int fchown(int fd, int uid, int gid); } 201 124 STD { int fchmod(int fd, int mode); } 202 125 MCPT_NOA { int recvfrom(int s, caddr_t buf, size_t len, int flags, \ 203 caddr_t from, int *fromlenaddr); } \ 204 recvfrom recvfrom_args int 205 126 MSTD { int setreuid(int ruid, int euid); } 206 127 MSTD { int setregid(int rgid, int egid); } 207 128 STD { int rename(char *from, char *to); } 208 129 COMPAT { int truncate(char *path, long length); } 209 130 COMPAT { int ftruncate(int fd, long length); } 210 131 MSTD { int flock(int fd, int how); } 211 132 STD { int mkfifo(char *path, int mode); } 212 133 MSTD { int sendto(int s, caddr_t buf, size_t len, int flags, \ 213 caddr_t to, int tolen); } 214 134 MSTD { int shutdown(int s, int how); } 215 135 MSTD { int socketpair(int domain, int type, int protocol, \ 216 int *rsv); } 217 136 STD { int mkdir(char *path, int mode); } 218 137 STD { int rmdir(char *path); } 219 138 STD { int utimes(char *path, struct timeval *tptr); } 220 139 OBSOL 4.2 sigreturn 221 140 MSTD { int adjtime(struct timeval *delta, \ 222 struct timeval *olddelta); } 223 141 MCOMPAT { int getpeername(int fdes, caddr_t asa, int *alen); } 224 142 MCOMPAT { long gethostid(void); } 225 143 MCOMPAT { int sethostid(long hostid); } 226 144 MCOMPAT { int getrlimit(u_int which, struct orlimit *rlp); } 227 145 MCOMPAT { int setrlimit(u_int which, struct orlimit *rlp); } 228 146 MCOMPAT { int killpg(int pgid, int signum); } 229 147 MSTD { int setsid(void); } 230 148 STD { int quotactl(char *path, int cmd, int uid, caddr_t arg); } 231 149 MCOMPAT { int quota(void); } 232 150 MCPT_NOA { int getsockname(int fdec, caddr_t asa, int *alen); }\ 233 getsockname getsockname_args int 234 235 ; Syscalls 151-180 inclusive are reserved for vendor-specific 236 ; system calls. (This includes various calls added for compatibity 237 ; with other Unix variants.) 238 ; Some of these calls are now supported by BSD... 239 151 UNIMPL sem_lock (BSD/OS 2.x) 240 152 UNIMPL sem_wakeup (BSD/OS 2.x) 241 153 UNIMPL asyncdaemon (BSD/OS 2.x) 242 154 UNIMPL nosys 243 ; 155 is initialized by the NFS code, if present. 244 155 MNOIMPL { int nfssvc(int flag, caddr_t argp); } 245 156 COMPAT { int getdirentries(int fd, char *buf, u_int count, \ 246 long *basep); } 247 157 COMPAT4 { int statfs(char *path, struct ostatfs *buf); } 248 158 COMPAT4 { int fstatfs(int fd, struct ostatfs *buf); } 249 159 UNIMPL nosys 250 160 STD { int lgetfh(char *fname, struct fhandle *fhp); } 251 161 STD { int getfh(char *fname, struct fhandle *fhp); } 252 162 MSTD { int getdomainname(char *domainname, int len); } 253 163 MSTD { int setdomainname(char *domainname, int len); } 254 164 MSTD { int uname(struct utsname *name); } 255 165 MSTD { int sysarch(int op, char *parms); } 256 166 MSTD { int rtprio(int function, pid_t pid, struct rtprio *rtp); } 257 167 UNIMPL nosys 258 168 UNIMPL nosys 259 ; 169 is initialized by the SYSVSEM code if present or loaded 260 169 MNOSTD { int semsys(int which, int a2, int a3, int a4, int a5); } 261 ; 169 is initialized by the SYSVMSG code if present or loaded 262 ; XXX should be { int semsys(int which, ...); } 263 170 MNOSTD { int msgsys(int which, int a2, int a3, int a4, int a5, \ 264 int a6); } 265 ; 169 is initialized by the SYSVSHM code if present or loaded 266 ; XXX should be { int msgsys(int which, ...); } 267 171 MNOSTD { int shmsys(int which, int a2, int a3, int a4); } 268 ; XXX should be { int shmsys(int which, ...); } 269 172 UNIMPL nosys 270 173 MSTD { ssize_t pread(int fd, void *buf, size_t nbyte, \ 271 int pad, off_t offset); } 272 174 MSTD { ssize_t pwrite(int fd, const void *buf, \ 273 size_t nbyte, int pad, off_t offset); } 274 175 UNIMPL nosys 275 176 MSTD { int ntp_adjtime(struct timex *tp); } 276 177 UNIMPL sfork (BSD/OS 2.x) 277 178 UNIMPL getdescriptor (BSD/OS 2.x) 278 179 UNIMPL setdescriptor (BSD/OS 2.x) 279 180 UNIMPL nosys 280 281 ; Syscalls 181-199 are used by/reserved for BSD 282 181 MSTD { int setgid(gid_t gid); } 283 182 MSTD { int setegid(gid_t egid); } 284 183 MSTD { int seteuid(uid_t euid); } 285 184 UNIMPL lfs_bmapv 286 185 UNIMPL lfs_markv 287 186 UNIMPL lfs_segclean 288 187 UNIMPL lfs_segwait 289 188 STD { int stat(char *path, struct stat *ub); } 290 189 MSTD { int fstat(int fd, struct stat *sb); } 291 190 STD { int lstat(char *path, struct stat *ub); } 292 191 STD { int pathconf(char *path, int name); } 293 192 MSTD { int fpathconf(int fd, int name); } 294 193 UNIMPL nosys 295 194 MSTD { int getrlimit(u_int which, struct rlimit *rlp); } \ 296 getrlimit __getrlimit_args int 297 195 MSTD { int setrlimit(u_int which, struct rlimit *rlp); } \ 298 setrlimit __setrlimit_args int 299 196 STD { int getdirentries(int fd, char *buf, u_int count, \ 300 long *basep); } 301 197 MSTD { caddr_t mmap(caddr_t addr, size_t len, int prot, \ 302 int flags, int fd, int pad, off_t pos); } 303 198 STD { int nosys(void); } __syscall __syscall_args int 304 199 STD { off_t lseek(int fd, int pad, off_t offset, int whence); } 305 200 STD { int truncate(char *path, int pad, off_t length); } 306 201 STD { int ftruncate(int fd, int pad, off_t length); } 307 202 MSTD { int __sysctl(int *name, u_int namelen, void *old, \ 308 size_t *oldlenp, void *new, size_t newlen); } \ 309 __sysctl sysctl_args int 310 203 MSTD { int mlock(const void *addr, size_t len); } 311 204 MSTD { int munlock(const void *addr, size_t len); } 312 205 STD { int undelete(char *path); } 313 206 STD { int futimes(int fd, struct timeval *tptr); } 314 207 MSTD { int getpgid(pid_t pid); } 315 208 UNIMPL newreboot (NetBSD) 316 209 MSTD { int poll(struct pollfd *fds, u_int nfds, int timeout); } 317 318 ; 319 ; The following are reserved for loadable syscalls 320 ; 321 210 NODEF lkmnosys lkmnosys nosys_args int 322 211 NODEF lkmnosys lkmnosys nosys_args int 323 212 NODEF lkmnosys lkmnosys nosys_args int 324 213 NODEF lkmnosys lkmnosys nosys_args int 325 214 NODEF lkmnosys lkmnosys nosys_args int 326 215 NODEF lkmnosys lkmnosys nosys_args int 327 216 NODEF lkmnosys lkmnosys nosys_args int 328 217 NODEF lkmnosys lkmnosys nosys_args int 329 218 NODEF lkmnosys lkmnosys nosys_args int 330 219 NODEF lkmnosys lkmnosys nosys_args int 331 332 ; 333 ; The following were introduced with NetBSD/4.4Lite-2 334 ; They are initialized by thier respective modules/sysinits 335 220 MNOSTD { int __semctl(int semid, int semnum, int cmd, \ 336 union semun *arg); } 337 221 MNOSTD { int semget(key_t key, int nsems, int semflg); } 338 222 MNOSTD { int semop(int semid, struct sembuf *sops, size_t nsops); } 339 223 UNIMPL semconfig 340 224 MNOSTD { int msgctl(int msqid, int cmd, struct msqid_ds *buf); } 341 225 MNOSTD { int msgget(key_t key, int msgflg); } 342 226 MNOSTD { int msgsnd(int msqid, const void *msgp, size_t msgsz, \ 343 int msgflg); } 344 227 MNOSTD { int msgrcv(int msqid, void *msgp, size_t msgsz, \ 345 long msgtyp, int msgflg); } 346 228 MNOSTD { int shmat(int shmid, const void *shmaddr, int shmflg); } 347 229 MNOSTD { int shmctl(int shmid, int cmd, struct shmid_ds *buf); } 348 230 MNOSTD { int shmdt(const void *shmaddr); } 349 231 MNOSTD { int shmget(key_t key, size_t size, int shmflg); } 350 ; 351 232 MSTD { int clock_gettime(clockid_t clock_id, struct timespec *tp); } 352 233 MSTD { int clock_settime(clockid_t clock_id, \ 353 const struct timespec *tp); } 354 234 MSTD { int clock_getres(clockid_t clock_id, struct timespec *tp); } 355 235 UNIMPL timer_create 356 236 UNIMPL timer_delete 357 237 UNIMPL timer_settime 358 238 UNIMPL timer_gettime 359 239 UNIMPL timer_getoverrun 360 240 MSTD { int nanosleep(const struct timespec *rqtp, \ 361 struct timespec *rmtp); } 362 241 UNIMPL nosys 363 242 UNIMPL nosys 364 243 UNIMPL nosys 365 244 UNIMPL nosys 366 245 UNIMPL nosys 367 246 UNIMPL nosys 368 247 UNIMPL nosys 369 248 UNIMPL nosys 370 249 UNIMPL nosys 371 ; syscall numbers initially used in OpenBSD 372 250 MSTD { int minherit(void *addr, size_t len, int inherit); } 373 251 MSTD { int rfork(int flags); } 374 252 MSTD { int openbsd_poll(struct pollfd *fds, u_int nfds, \ 375 int timeout); } 376 253 MSTD { int issetugid(void); } 377 254 STD { int lchown(char *path, int uid, int gid); } 378 255 UNIMPL nosys 379 256 UNIMPL nosys 380 257 UNIMPL nosys 381 258 UNIMPL nosys 382 259 UNIMPL nosys 383 260 UNIMPL nosys 384 261 UNIMPL nosys 385 262 UNIMPL nosys 386 263 UNIMPL nosys 387 264 UNIMPL nosys 388 265 UNIMPL nosys 389 266 UNIMPL nosys 390 267 UNIMPL nosys 391 268 UNIMPL nosys 392 269 UNIMPL nosys 393 270 UNIMPL nosys 394 271 UNIMPL nosys 395 272 STD { int getdents(int fd, char *buf, size_t count); } 396 273 UNIMPL nosys 397 274 STD { int lchmod(char *path, mode_t mode); } 398 275 NOPROTO { int lchown(char *path, uid_t uid, gid_t gid); } \ 399 netbsd_lchown lchown_args int 400 276 STD { int lutimes(char *path, struct timeval *tptr); } 401 277 MNOPROTO { int msync(void *addr, size_t len, int flags); } \ 402 netbsd_msync msync_args int 403 278 STD { int nstat(char *path, struct nstat *ub); } 404 279 MSTD { int nfstat(int fd, struct nstat *sb); } 405 280 STD { int nlstat(char *path, struct nstat *ub); } 406 281 UNIMPL nosys 407 282 UNIMPL nosys 408 283 UNIMPL nosys 409 284 UNIMPL nosys 410 285 UNIMPL nosys 411 286 UNIMPL nosys 412 287 UNIMPL nosys 413 288 UNIMPL nosys 414 ; 289 and 290 from NetBSD (OpenBSD: 267 and 268) 415 289 MSTD { ssize_t preadv(int fd, struct iovec *iovp, u_int iovcnt, \ 416 off_t offset); } 417 290 MSTD { ssize_t pwritev(int fd, struct iovec *iovp, u_int iovcnt, \ 418 off_t offset); } 419 291 UNIMPL nosys 420 292 UNIMPL nosys 421 293 UNIMPL nosys 422 294 UNIMPL nosys 423 295 UNIMPL nosys 424 296 UNIMPL nosys 425 ; XXX 297 is 300 in NetBSD 426 297 COMPAT4 { int fhstatfs(const struct fhandle *u_fhp, \ 427 struct ostatfs *buf); } 428 298 STD { int fhopen(const struct fhandle *u_fhp, int flags); } 429 299 STD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); } 430 ; syscall numbers for FreeBSD 431 300 MSTD { int modnext(int modid); } 432 301 MSTD { int modstat(int modid, struct module_stat* stat); } 433 302 MSTD { int modfnext(int modid); } 434 303 MSTD { int modfind(const char *name); } 435 304 MSTD { int kldload(const char *file); } 436 305 MSTD { int kldunload(int fileid); } 437 306 MSTD { int kldfind(const char *file); } 438 307 MSTD { int kldnext(int fileid); } 439 308 MSTD { int kldstat(int fileid, struct kld_file_stat* stat); } 440 309 MSTD { int kldfirstmod(int fileid); } 441 310 MSTD { int getsid(pid_t pid); } 442 311 MSTD { int setresuid(uid_t ruid, uid_t euid, uid_t suid); } 443 312 MSTD { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); } 444 313 OBSOL signanosleep 445 314 NOSTD { int aio_return(struct aiocb *aiocbp); } 446 315 NOSTD { int aio_suspend(struct aiocb * const * aiocbp, int nent, \ 447 const struct timespec *timeout); } 448 316 NOSTD { int aio_cancel(int fd, struct aiocb *aiocbp); } 449 317 NOSTD { int aio_error(struct aiocb *aiocbp); } 450 318 NOSTD { int aio_read(struct aiocb *aiocbp); } 451 319 NOSTD { int aio_write(struct aiocb *aiocbp); } 452 320 NOSTD { int lio_listio(int mode, struct aiocb * const *acb_list, \ 453 int nent, struct sigevent *sig); } 454 321 MSTD { int yield(void); } 455 322 OBSOL thr_sleep 456 323 OBSOL thr_wakeup 457 324 MSTD { int mlockall(int how); } 458 325 MSTD { int munlockall(void); } 459 326 STD { int __getcwd(u_char *buf, u_int buflen); } 460 461 327 MSTD { int sched_setparam (pid_t pid, \ 462 const struct sched_param *param); } 463 328 MSTD { int sched_getparam (pid_t pid, struct sched_param *param); } 464 465 329 MSTD { int sched_setscheduler (pid_t pid, int policy, \ 466 const struct sched_param *param); } 467 330 MSTD { int sched_getscheduler (pid_t pid); } 468 469 331 MSTD { int sched_yield (void); } 470 332 MSTD { int sched_get_priority_max (int policy); } 471 333 MSTD { int sched_get_priority_min (int policy); } 472 334 MSTD { int sched_rr_get_interval (pid_t pid, \ 473 struct timespec *interval); } 474 335 MSTD { int utrace(const void *addr, size_t len); } 475 336 MCOMPAT4 { int sendfile(int fd, int s, off_t offset, size_t nbytes, \ 476 struct sf_hdtr *hdtr, off_t *sbytes, int flags); } 477 337 STD { int kldsym(int fileid, int cmd, void *data); } 478 338 MSTD { int jail(struct jail *jail); } 479 339 UNIMPL pioctl 480 340 MSTD { int sigprocmask(int how, const sigset_t *set, \ 481 sigset_t *oset); } 482 341 MSTD { int sigsuspend(const sigset_t *sigmask); } 483 342 MCOMPAT4 { int sigaction(int sig, const struct sigaction *act, \ 484 struct sigaction *oact); } 485 343 MSTD { int sigpending(sigset_t *set); } 486 344 MCOMPAT4 { int sigreturn(const struct ucontext4 *sigcntxp); } 487 345 MSTD { int sigtimedwait(const sigset_t *set, \ 488 siginfo_t *info, const struct timespec *timeout); } 489 346 MSTD { int sigwaitinfo(const sigset_t *set, siginfo_t *info); } 490 347 MSTD { int __acl_get_file(const char *path, \ 491 acl_type_t type, struct acl *aclp); } 492 348 MSTD { int __acl_set_file(const char *path, \ 493 acl_type_t type, struct acl *aclp); } 494 349 MSTD { int __acl_get_fd(int filedes, acl_type_t type, \ 495 struct acl *aclp); } 496 350 MSTD { int __acl_set_fd(int filedes, acl_type_t type, \ 497 struct acl *aclp); } 498 351 MSTD { int __acl_delete_file(const char *path, acl_type_t type); } 499 352 MSTD { int __acl_delete_fd(int filedes, acl_type_t type); } 500 353 MSTD { int __acl_aclcheck_file(const char *path, \ 501 acl_type_t type, struct acl *aclp); } 502 354 MSTD { int __acl_aclcheck_fd(int filedes, acl_type_t type, \ 503 struct acl *aclp); } 504 355 STD { int extattrctl(const char *path, int cmd, \ 505 const char *filename, int attrnamespace, \ 506 const char *attrname); } 507 356 STD { int extattr_set_file(const char *path, \ 508 int attrnamespace, const char *attrname, \ 509 void *data, size_t nbytes); } 510 357 STD { ssize_t extattr_get_file(const char *path, \ 511 int attrnamespace, const char *attrname, \ 512 void *data, size_t nbytes); } 513 358 STD { int extattr_delete_file(const char *path, \ 514 int attrnamespace, const char *attrname); } 515 359 NOSTD { int aio_waitcomplete(struct aiocb **aiocbp, \ 516 struct timespec *timeout); } 517 360 MSTD { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); } 518 361 MSTD { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); } 519 362 MSTD { int kqueue(void); } 520 363 MSTD { int kevent(int fd, \ 521 struct kevent *changelist, int nchanges, \ 522 struct kevent *eventlist, int nevents, \ 523 const struct timespec *timeout); } 524 364 UNIMPL __cap_get_proc 525 365 UNIMPL __cap_set_proc 526 366 UNIMPL __cap_get_fd 527 367 UNIMPL __cap_get_file 528 368 UNIMPL __cap_set_fd 529 369 UNIMPL __cap_set_file 530 370 NODEF lkmressys lkmressys nosys_args int 531 371 STD { int extattr_set_fd(int fd, int attrnamespace, \ 532 const char *attrname, void *data, \ 533 size_t nbytes); } 534 372 STD { ssize_t extattr_get_fd(int fd, int attrnamespace, \ 535 const char *attrname, void *data, size_t nbytes); } 536 373 STD { int extattr_delete_fd(int fd, int attrnamespace, \ 537 const char *attrname); } 538 374 MSTD { int __setugid(int flag); } 539 375 NOIMPL { int nfsclnt(int flag, caddr_t argp); } 540 376 STD { int eaccess(char *path, int flags); } 541 377 UNIMPL afs_syscall 542 378 STD { int nmount(struct iovec *iovp, unsigned int iovcnt, \ 543 int flags); } 544 379 MSTD { int kse_exit(void); } 545 380 MSTD { int kse_wakeup(struct kse_mailbox *mbx); } 546 381 MSTD { int kse_create(struct kse_mailbox *mbx, \ 547 int newgroup); } 548 382 MSTD { int kse_thr_interrupt(struct kse_thr_mailbox *tmbx, int cmd, \ 549 long data); } 550 383 MSTD { int kse_release(struct timespec *timeout); } 551 384 MSTD { int __mac_get_proc(struct mac *mac_p); } 552 385 MSTD { int __mac_set_proc(struct mac *mac_p); } 553 386 MSTD { int __mac_get_fd(int fd, struct mac *mac_p); } 554 387 MSTD { int __mac_get_file(const char *path_p, \ 555 struct mac *mac_p); } 556 388 MSTD { int __mac_set_fd(int fd, struct mac *mac_p); } 557 389 MSTD { int __mac_set_file(const char *path_p, \ 558 struct mac *mac_p); } 559 390 STD { int kenv(int what, const char *name, char *value, \ 560 int len); } 561 391 STD { int lchflags(const char *path, int flags); } 562 392 STD { int uuidgen(struct uuid *store, int count); } 563 393 MSTD { int sendfile(int fd, int s, off_t offset, size_t nbytes, \ 564 struct sf_hdtr *hdtr, off_t *sbytes, int flags); } 565 394 MSTD { int mac_syscall(const char *policy, int call, \ 566 void *arg); } 567 395 STD { int getfsstat(struct statfs *buf, long bufsize, \ 568 int flags); } 569 396 STD { int statfs(char *path, struct statfs *buf); } 570 397 STD { int fstatfs(int fd, struct statfs *buf); } 571 398 STD { int fhstatfs(const struct fhandle *u_fhp, \ 572 struct statfs *buf); } 573 399 UNIMPL nosys 574 400 MNOSTD { int ksem_close(semid_t id); } 575 401 MNOSTD { int ksem_post(semid_t id); } 576 402 MNOSTD { int ksem_wait(semid_t id); } 577 403 MNOSTD { int ksem_trywait(semid_t id); } 578 404 MNOSTD { int ksem_init(semid_t *idp, unsigned int value); } 579 405 MNOSTD { int ksem_open(semid_t *idp, const char *name, \ 580 int oflag, mode_t mode, unsigned int value); } 581 406 MNOSTD { int ksem_unlink(const char *name); } 582 407 MNOSTD { int ksem_getvalue(semid_t id, int *val); } 583 408 MNOSTD { int ksem_destroy(semid_t id); } 584 409 MSTD { int __mac_get_pid(pid_t pid, struct mac *mac_p); } 585 410 MSTD { int __mac_get_link(const char *path_p, \ 586 struct mac *mac_p); } 587 411 MSTD { int __mac_set_link(const char *path_p, \ 588 struct mac *mac_p); } 589 412 STD { int extattr_set_link(const char *path, \ 590 int attrnamespace, const char *attrname, \ 591 void *data, size_t nbytes); } 592 413 STD { ssize_t extattr_get_link(const char *path, \ 593 int attrnamespace, const char *attrname, \ 594 void *data, size_t nbytes); } 595 414 STD { int extattr_delete_link(const char *path, \ 596 int attrnamespace, const char *attrname); } 597 415 MSTD { int __mac_execve(char *fname, char **argv, \ 598 char **envv, struct mac *mac_p); } 599 416 MSTD { int sigaction(int sig, const struct sigaction *act, \ 600 struct sigaction *oact); } 601 417 MSTD { int sigreturn(const struct __ucontext *sigcntxp); } 602 418 UNIMPL __xstat 603 419 UNIMPL __xfstat 604 420 UNIMPL __xlstat 605 421 MSTD { int getcontext(struct __ucontext *ucp); } 606 422 MSTD { int setcontext(const struct __ucontext *ucp); } 607 423 MSTD { int swapcontext(struct __ucontext *oucp, \ 608 const struct __ucontext *ucp); } 609 424 MSTD { int swapoff(const char *name); } 610 425 MSTD { int __acl_get_link(const char *path, \ 611 acl_type_t type, struct acl *aclp); } 612 426 MSTD { int __acl_set_link(const char *path, \ 613 acl_type_t type, struct acl *aclp); } 614 427 MSTD { int __acl_delete_link(const char *path, \ 615 acl_type_t type); } 616 428 MSTD { int __acl_aclcheck_link(const char *path, \ 617 acl_type_t type, struct acl *aclp); } 618 429 MSTD { int sigwait(const sigset_t *set, int *sig); } 619 430 MSTD { int thr_create(ucontext_t *ctx, long *id, int flags); } 620 431 MSTD { void thr_exit(long *state); } 621 432 MSTD { int thr_self(long *id); } 622 433 MSTD { int thr_kill(long id, int sig); } 623 434 MSTD { int _umtx_lock(struct umtx *umtx); } 624 435 MSTD { int _umtx_unlock(struct umtx *umtx); } 625 436 MSTD { int jail_attach(int jid); } 626 437 STD { ssize_t extattr_list_fd(int fd, int attrnamespace, \ 627 void *data, size_t nbytes); } 628 438 STD { ssize_t extattr_list_file(const char *path, \ 629 int attrnamespace, void *data, size_t nbytes); } 630 439 STD { ssize_t extattr_list_link(const char *path, \ 631 int attrnamespace, void *data, size_t nbytes); } 632 440 MSTD { int kse_switchin(struct kse_thr_mailbox *tmbx, \ 633 int flags); } 634 441 MNOSTD { int ksem_timedwait(semid_t id, struct timespec *abstime); } 635 442 MSTD { int thr_suspend(const struct timespec *timeout); } 636 443 MSTD { int thr_wake(long id); } 637 444 MSTD { int kldunloadf(int fileid, int flags); } 638 ; Please copy any additions and changes to the following compatability tables: 639 ; sys/compat/freebsd32/syscalls.master
Cache object: 05a6b38f25cf77c31e34c182832908a3
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]