| @@ -1,1048 +1,1048 @@ | | | @@ -1,1048 +1,1048 @@ |
1 | $NetBSD: syscalls.master,v 1.306 2020/08/14 00:53:16 riastradh Exp $ | | 1 | $NetBSD: syscalls.master,v 1.307 2020/11/02 18:55:12 christos Exp $ |
2 | | | 2 | |
3 | ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 | | 3 | ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 |
4 | | | 4 | |
5 | ; NetBSD system call name/number "master" file. | | 5 | ; NetBSD system call name/number "master" file. |
6 | ; (See syscalls.conf to see what it is processed into.) | | 6 | ; (See syscalls.conf to see what it is processed into.) |
7 | ; | | 7 | ; |
8 | ; Fields: number type [type-dependent ...] | | 8 | ; Fields: number type [type-dependent ...] |
9 | ; number system call number, must be in order | | 9 | ; number system call number, must be in order |
10 | ; type one of STD, OBSOL, UNIMPL, IGNORED, NODEF, NOARGS, or one of | | 10 | ; type one of STD, OBSOL, UNIMPL, IGNORED, NODEF, NOARGS, or one of |
11 | ; the compatibility options defined in syscalls.conf. | | 11 | ; the compatibility options defined in syscalls.conf. |
12 | ; | | 12 | ; |
13 | ; Optional fields are specified after the type field | | 13 | ; Optional fields are specified after the type field |
14 | ; (NOTE! they *must* be specified in this order): | | 14 | ; (NOTE! they *must* be specified in this order): |
15 | ; MODULAR modname :attempt to autoload system call module if not present | | 15 | ; MODULAR modname :attempt to autoload system call module if not present |
16 | ; RUMP: generate rump syscall entry point | | 16 | ; RUMP: generate rump syscall entry point |
17 | ; | | 17 | ; |
18 | ; types: | | 18 | ; types: |
19 | ; STD always included | | 19 | ; STD always included |
20 | ; OBSOL obsolete, not included in system | | 20 | ; OBSOL obsolete, not included in system |
21 | ; IGNORED syscall is a null op, but always succeeds | | 21 | ; IGNORED syscall is a null op, but always succeeds |
22 | ; UNIMPL unimplemented, not included in system | | 22 | ; UNIMPL unimplemented, not included in system |
23 | ; EXCL implemented, but not included in system | | 23 | ; EXCL implemented, but not included in system |
24 | ; NODEF included, but don't define the syscall number | | 24 | ; NODEF included, but don't define the syscall number |
25 | ; NOARGS included, but don't define the syscall args structure | | 25 | ; NOARGS included, but don't define the syscall args structure |
26 | ; INDIR included, but don't define the syscall args structure, | | 26 | ; INDIR included, but don't define the syscall args structure, |
27 | ; and allow it to be "really" varargs. | | 27 | ; and allow it to be "really" varargs. |
28 | ; NOERR included, syscall does not set errno | | 28 | ; NOERR included, syscall does not set errno |
29 | ; EXTERN implemented, but as 3rd party module | | 29 | ; EXTERN implemented, but as 3rd party module |
30 | ; | | 30 | ; |
31 | ; arguments: | | 31 | ; arguments: |
32 | ; PAD argument not part of the C interface, used only for padding | | 32 | ; PAD argument not part of the C interface, used only for padding |
33 | ; | | 33 | ; |
34 | ; The compat options are defined in the syscalls.conf file, and the | | 34 | ; The compat options are defined in the syscalls.conf file, and the |
35 | ; compat option name is prefixed to the syscall name. Other than | | 35 | ; compat option name is prefixed to the syscall name. Other than |
36 | ; that, they're like NODEF (for 'compat' options), or STD (for | | 36 | ; that, they're like NODEF (for 'compat' options), or STD (for |
37 | ; 'libcompat' options). | | 37 | ; 'libcompat' options). |
38 | ; | | 38 | ; |
39 | ; The type-dependent arguments are as follows: | | 39 | ; The type-dependent arguments are as follows: |
40 | ; For STD, NODEF, NOARGS, and compat syscalls: | | 40 | ; For STD, NODEF, NOARGS, and compat syscalls: |
41 | ; { return_type|prefix|compat(optional)|basename(pseudo-proto); } [alias] | | 41 | ; { return_type|prefix|compat(optional)|basename(pseudo-proto); } [alias] |
42 | ; For other syscalls: | | 42 | ; For other syscalls: |
43 | ; [comment] | | 43 | ; [comment] |
44 | ; | | 44 | ; |
45 | ; #ifdef's, etc. may be included, and are copied to the output files. | | 45 | ; #ifdef's, etc. may be included, and are copied to the output files. |
46 | ; #include's are copied to the syscall names and switch definition files only. | | 46 | ; #include's are copied to the syscall names and switch definition files only. |
47 | | | 47 | |
48 | #ifdef _KERNEL_OPT | | 48 | #ifdef _KERNEL_OPT |
49 | #include "opt_modular.h" | | 49 | #include "opt_modular.h" |
50 | #include "opt_ntp.h" | | 50 | #include "opt_ntp.h" |
51 | #include "opt_sysv.h" | | 51 | #include "opt_sysv.h" |
52 | #endif | | 52 | #endif |
53 | | | 53 | |
54 | #include <sys/param.h> | | 54 | #include <sys/param.h> |
55 | #include <sys/systm.h> | | 55 | #include <sys/systm.h> |
56 | #include <sys/signal.h> | | 56 | #include <sys/signal.h> |
57 | #include <sys/socket.h> | | 57 | #include <sys/socket.h> |
58 | #include <sys/mount.h> | | 58 | #include <sys/mount.h> |
59 | #include <sys/sched.h> | | 59 | #include <sys/sched.h> |
60 | #include <sys/idtype.h> | | 60 | #include <sys/idtype.h> |
61 | #include <sys/syscallargs.h> | | 61 | #include <sys/syscallargs.h> |
62 | #include <sys/acl.h> | | 62 | #include <sys/acl.h> |
63 | | | 63 | |
64 | %% | | 64 | %% |
65 | | | 65 | |
66 | ; Reserved/unimplemented system calls in the range 0-150 inclusive | | 66 | ; Reserved/unimplemented system calls in the range 0-150 inclusive |
67 | ; are reserved for use in future Berkeley releases. | | 67 | ; are reserved for use in future Berkeley releases. |
68 | ; Additional system calls implemented in vendor and other | | 68 | ; Additional system calls implemented in vendor and other |
69 | ; redistributions should be placed in the reserved range at the end | | 69 | ; redistributions should be placed in the reserved range at the end |
70 | ; of the current calls. | | 70 | ; of the current calls. |
71 | | | 71 | |
72 | 0 INDIR { int|sys||syscall(int code, \ | | 72 | 0 INDIR { int|sys||syscall(int code, \ |
73 | ... register_t args[SYS_MAXSYSARGS]); } | | 73 | ... register_t args[SYS_MAXSYSARGS]); } |
74 | 1 STD { void|sys||exit(int rval); } | | 74 | 1 STD { void|sys||exit(int rval); } |
75 | 2 STD { int|sys||fork(void); } | | 75 | 2 STD { int|sys||fork(void); } |
76 | 3 STD RUMP { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } | | 76 | 3 STD RUMP { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } |
77 | 4 STD RUMP { ssize_t|sys||write(int fd, const void *buf, \ | | 77 | 4 STD RUMP { ssize_t|sys||write(int fd, const void *buf, \ |
78 | size_t nbyte); } | | 78 | size_t nbyte); } |
79 | 5 STD RUMP { int|sys||open(const char *path, \ | | 79 | 5 STD RUMP { int|sys||open(const char *path, \ |
80 | int flags, ... mode_t mode); } | | 80 | int flags, ... mode_t mode); } |
81 | 6 STD RUMP { int|sys||close(int fd); } | | 81 | 6 STD RUMP { int|sys||close(int fd); } |
82 | 7 COMPAT_50 MODULAR compat_50 { int|sys||wait4(pid_t pid, int *status, \ | | 82 | 7 COMPAT_50 MODULAR compat_50 { int|sys||wait4(pid_t pid, int *status, \ |
83 | int options, struct rusage50 *rusage); } | | 83 | int options, struct rusage50 *rusage); } |
84 | 8 COMPAT_43 MODULAR compat_43 \ | | 84 | 8 COMPAT_43 MODULAR compat_43 \ |
85 | { int|sys||creat(const char *path, mode_t mode); } ocreat | | 85 | { int|sys||creat(const char *path, mode_t mode); } ocreat |
86 | 9 STD RUMP { int|sys||link(const char *path, const char *link); } | | 86 | 9 STD RUMP { int|sys||link(const char *path, const char *link); } |
87 | 10 STD RUMP { int|sys||unlink(const char *path); } | | 87 | 10 STD RUMP { int|sys||unlink(const char *path); } |
88 | 11 OBSOL execv | | 88 | 11 OBSOL execv |
89 | 12 STD RUMP { int|sys||chdir(const char *path); } | | 89 | 12 STD RUMP { int|sys||chdir(const char *path); } |
90 | 13 STD RUMP { int|sys||fchdir(int fd); } | | 90 | 13 STD RUMP { int|sys||fchdir(int fd); } |
91 | 14 COMPAT_50 MODULAR compat_50 RUMP \ | | 91 | 14 COMPAT_50 MODULAR compat_50 RUMP \ |
92 | { int|sys||mknod(const char *path, mode_t mode, uint32_t dev); } | | 92 | { int|sys||mknod(const char *path, mode_t mode, uint32_t dev); } |
93 | 15 STD RUMP { int|sys||chmod(const char *path, mode_t mode); } | | 93 | 15 STD RUMP { int|sys||chmod(const char *path, mode_t mode); } |
94 | 16 STD RUMP { int|sys||chown(const char *path, uid_t uid, \ | | 94 | 16 STD RUMP { int|sys||chown(const char *path, uid_t uid, \ |
95 | gid_t gid); } | | 95 | gid_t gid); } |
96 | 17 STD { int|sys||obreak(char *nsize); } break | | 96 | 17 STD { int|sys||obreak(char *nsize); } break |
97 | 18 COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \ | | 97 | 18 COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \ |
98 | long bufsize, int flags); } | | 98 | long bufsize, int flags); } |
99 | 19 COMPAT_43 MODULAR compat_43 \ | | 99 | 19 COMPAT_43 MODULAR compat_43 \ |
100 | { long|sys||lseek(int fd, long offset, int whence); }\ | | 100 | { long|sys||lseek(int fd, long offset, int whence); }\ |
101 | olseek | | 101 | olseek |
102 | 20 NOERR RUMP { pid_t|sys||getpid_with_ppid(void); } getpid | | 102 | 20 NOERR RUMP { pid_t|sys||getpid_with_ppid(void); } getpid |
103 | 21 COMPAT_40 MODULAR compat_40 \ | | 103 | 21 COMPAT_40 MODULAR compat_40 \ |
104 | { int|sys||mount(const char *type, const char *path, \ | | 104 | { int|sys||mount(const char *type, const char *path, \ |
105 | int flags, void *data); } | | 105 | int flags, void *data); } |
106 | 22 STD RUMP { int|sys||unmount(const char *path, int flags); } | | 106 | 22 STD RUMP { int|sys||unmount(const char *path, int flags); } |
107 | 23 STD RUMP { int|sys||setuid(uid_t uid); } | | 107 | 23 STD RUMP { int|sys||setuid(uid_t uid); } |
108 | 24 NOERR RUMP { uid_t|sys||getuid_with_euid(void); } getuid | | 108 | 24 NOERR RUMP { uid_t|sys||getuid_with_euid(void); } getuid |
109 | 25 NOERR RUMP { uid_t|sys||geteuid(void); } | | 109 | 25 NOERR RUMP { uid_t|sys||geteuid(void); } |
110 | 26 STD MODULAR ptrace \ | | 110 | 26 STD MODULAR ptrace \ |
111 | { int|sys||ptrace(int req, pid_t pid, void *addr, \ | | 111 | { int|sys||ptrace(int req, pid_t pid, void *addr, \ |
112 | int data); } | | 112 | int data); } |
113 | 27 STD RUMP { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \ | | 113 | 27 STD RUMP { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \ |
114 | int flags); } | | 114 | int flags); } |
115 | 28 STD RUMP { ssize_t|sys||sendmsg(int s, \ | | 115 | 28 STD RUMP { ssize_t|sys||sendmsg(int s, \ |
116 | const struct msghdr *msg, int flags); } | | 116 | const struct msghdr *msg, int flags); } |
117 | 29 STD RUMP { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \ | | 117 | 29 STD RUMP { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \ |
118 | int flags, struct sockaddr *from, \ | | 118 | int flags, struct sockaddr *from, \ |
119 | socklen_t *fromlenaddr); } | | 119 | socklen_t *fromlenaddr); } |
120 | 30 STD RUMP { int|sys||accept(int s, struct sockaddr *name, \ | | 120 | 30 STD RUMP { int|sys||accept(int s, struct sockaddr *name, \ |
121 | socklen_t *anamelen); } | | 121 | socklen_t *anamelen); } |
122 | 31 STD RUMP { int|sys||getpeername(int fdes, struct sockaddr *asa, \ | | 122 | 31 STD RUMP { int|sys||getpeername(int fdes, struct sockaddr *asa, \ |
123 | socklen_t *alen); } | | 123 | socklen_t *alen); } |
124 | 32 STD RUMP { int|sys||getsockname(int fdes, struct sockaddr *asa, \ | | 124 | 32 STD RUMP { int|sys||getsockname(int fdes, struct sockaddr *asa, \ |
125 | socklen_t *alen); } | | 125 | socklen_t *alen); } |
126 | 33 STD RUMP { int|sys||access(const char *path, int flags); } | | 126 | 33 STD RUMP { int|sys||access(const char *path, int flags); } |
127 | 34 STD RUMP { int|sys||chflags(const char *path, u_long flags); } | | 127 | 34 STD RUMP { int|sys||chflags(const char *path, u_long flags); } |
128 | 35 STD RUMP { int|sys||fchflags(int fd, u_long flags); } | | 128 | 35 STD RUMP { int|sys||fchflags(int fd, u_long flags); } |
129 | 36 NOERR RUMP { void|sys||sync(void); } | | 129 | 36 NOERR RUMP { void|sys||sync(void); } |
130 | 37 STD { int|sys||kill(pid_t pid, int signum); } | | 130 | 37 STD { int|sys||kill(pid_t pid, int signum); } |
131 | 38 COMPAT_43 MODULAR compat_43 \ | | 131 | 38 COMPAT_43 MODULAR compat_43 \ |
132 | { int|sys||stat(const char *path, struct stat43 *ub); } stat43 | | 132 | { int|sys||stat(const char *path, struct stat43 *ub); } stat43 |
133 | 39 NOERR RUMP { pid_t|sys||getppid(void); } | | 133 | 39 NOERR RUMP { pid_t|sys||getppid(void); } |
134 | 40 COMPAT_43 MODULAR compat_43 \ | | 134 | 40 COMPAT_43 MODULAR compat_43 \ |
135 | { int|sys||lstat(const char *path, \ | | 135 | { int|sys||lstat(const char *path, \ |
136 | struct stat43 *ub); } lstat43 | | 136 | struct stat43 *ub); } lstat43 |
137 | 41 STD RUMP { int|sys||dup(int fd); } | | 137 | 41 STD RUMP { int|sys||dup(int fd); } |
138 | 42 STD RUMP { int|sys||pipe(void); } | | 138 | 42 STD RUMP { int|sys||pipe(void); } |
139 | 43 NOERR RUMP { gid_t|sys||getegid(void); } | | 139 | 43 NOERR RUMP { gid_t|sys||getegid(void); } |
140 | 44 STD { int|sys||profil(char *samples, size_t size, \ | | 140 | 44 STD { int|sys||profil(char *samples, size_t size, \ |
141 | u_long offset, u_int scale); } | | 141 | u_long offset, u_int scale); } |
142 | 45 STD RUMP { int|sys||ktrace(const char *fname, int ops, \ | | 142 | 45 STD RUMP { int|sys||ktrace(const char *fname, int ops, \ |
143 | int facs, pid_t pid); } | | 143 | int facs, pid_t pid); } |
144 | 46 COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \ | | 144 | 46 COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \ |
145 | const struct sigaction13 *nsa, \ | | 145 | const struct sigaction13 *nsa, \ |
146 | struct sigaction13 *osa); } sigaction13 | | 146 | struct sigaction13 *osa); } sigaction13 |
147 | 47 NOERR RUMP { gid_t|sys||getgid_with_egid(void); } getgid | | 147 | 47 NOERR RUMP { gid_t|sys||getgid_with_egid(void); } getgid |
148 | 48 COMPAT_13 MODULAR compat_13 { int|sys||sigprocmask(int how, \ | | 148 | 48 COMPAT_13 MODULAR compat_13 { int|sys||sigprocmask(int how, \ |
149 | int mask); } sigprocmask13 | | 149 | int mask); } sigprocmask13 |
150 | 49 STD RUMP { int|sys||__getlogin(char *namebuf, size_t namelen); } | | 150 | 49 STD RUMP { int|sys||__getlogin(char *namebuf, size_t namelen); } |
151 | 50 STD RUMP { int|sys||__setlogin(const char *namebuf); } | | 151 | 50 STD RUMP { int|sys||__setlogin(const char *namebuf); } |
152 | 51 STD { int|sys||acct(const char *path); } | | 152 | 51 STD { int|sys||acct(const char *path); } |
153 | 52 COMPAT_13 MODULAR compat_13 { int|sys||sigpending(void); } sigpending13 | | 153 | 52 COMPAT_13 MODULAR compat_13 { int|sys||sigpending(void); } sigpending13 |
154 | 53 COMPAT_13 MODULAR compat_13 { int|sys||sigaltstack( \ | | 154 | 53 COMPAT_13 MODULAR compat_13 { int|sys||sigaltstack( \ |
155 | const struct sigaltstack13 *nss, \ | | 155 | const struct sigaltstack13 *nss, \ |
156 | struct sigaltstack13 *oss); } sigaltstack13 | | 156 | struct sigaltstack13 *oss); } sigaltstack13 |
157 | 54 STD RUMP { int|sys||ioctl(int fd, \ | | 157 | 54 STD RUMP { int|sys||ioctl(int fd, \ |
158 | u_long com, ... void *data); } | | 158 | u_long com, ... void *data); } |
159 | 55 COMPAT_12 MODULAR compat_12 { int|sys||reboot(int opt); } oreboot | | 159 | 55 COMPAT_12 MODULAR compat_12 { int|sys||reboot(int opt); } oreboot |
160 | 56 STD RUMP { int|sys||revoke(const char *path); } | | 160 | 56 STD RUMP { int|sys||revoke(const char *path); } |
161 | 57 STD RUMP { int|sys||symlink(const char *path, \ | | 161 | 57 STD RUMP { int|sys||symlink(const char *path, \ |
162 | const char *link); } | | 162 | const char *link); } |
163 | 58 STD RUMP { ssize_t|sys||readlink(const char *path, char *buf, \ | | 163 | 58 STD RUMP { ssize_t|sys||readlink(const char *path, char *buf, \ |
164 | size_t count); } | | 164 | size_t count); } |
165 | 59 STD { int|sys||execve(const char *path, \ | | 165 | 59 STD { int|sys||execve(const char *path, \ |
166 | char * const *argp, char * const *envp); } | | 166 | char * const *argp, char * const *envp); } |
167 | 60 STD RUMP { mode_t|sys||umask(mode_t newmask); } | | 167 | 60 STD RUMP { mode_t|sys||umask(mode_t newmask); } |
168 | 61 STD RUMP { int|sys||chroot(const char *path); } | | 168 | 61 STD RUMP { int|sys||chroot(const char *path); } |
169 | 62 COMPAT_43 MODULAR compat_43 \ | | 169 | 62 COMPAT_43 MODULAR compat_43 \ |
170 | { int|sys||fstat(int fd, struct stat43 *sb); } fstat43 | | 170 | { int|sys||fstat(int fd, struct stat43 *sb); } fstat43 |
171 | 63 COMPAT_43 MODULAR compat_43 \ | | 171 | 63 COMPAT_43 MODULAR compat_43 \ |
172 | { int|sys||getkerninfo(int op, char *where, int *size, \ | | 172 | { int|sys||getkerninfo(int op, char *where, int *size, \ |
173 | int arg); } ogetkerninfo | | 173 | int arg); } ogetkerninfo |
174 | 64 COMPAT_43 MODULAR compat_43 \ | | 174 | 64 COMPAT_43 MODULAR compat_43 \ |
175 | { int|sys||getpagesize(void); } ogetpagesize | | 175 | { int|sys||getpagesize(void); } ogetpagesize |
176 | 65 COMPAT_12 MODULAR compat_12 { int|sys||msync(void *addr, size_t len); } | | 176 | 65 COMPAT_12 MODULAR compat_12 { int|sys||msync(void *addr, size_t len); } |
177 | ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? | | 177 | ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? |
178 | 66 STD { int|sys||vfork(void); } | | 178 | 66 STD { int|sys||vfork(void); } |
179 | 67 OBSOL vread | | 179 | 67 OBSOL vread |
180 | 68 OBSOL vwrite | | 180 | 68 OBSOL vwrite |
181 | 69 OBSOL sbrk | | 181 | 69 OBSOL sbrk |
182 | 70 OBSOL sstk | | 182 | 70 OBSOL sstk |
183 | 71 COMPAT_43 MODULAR compat_43 \ | | 183 | 71 COMPAT_43 MODULAR compat_43 \ |
184 | { int|sys||mmap(void *addr, size_t len, int prot, \ | | 184 | { int|sys||mmap(void *addr, size_t len, int prot, \ |
185 | int flags, int fd, long pos); } ommap | | 185 | int flags, int fd, long pos); } ommap |
186 | 72 STD { int|sys||ovadvise(int anom); } vadvise | | 186 | 72 STD { int|sys||ovadvise(int anom); } vadvise |
187 | 73 STD { int|sys||munmap(void *addr, size_t len); } | | 187 | 73 STD { int|sys||munmap(void *addr, size_t len); } |
188 | 74 STD { int|sys||mprotect(void *addr, size_t len, \ | | 188 | 74 STD { int|sys||mprotect(void *addr, size_t len, \ |
189 | int prot); } | | 189 | int prot); } |
190 | 75 STD { int|sys||madvise(void *addr, size_t len, \ | | 190 | 75 STD { int|sys||madvise(void *addr, size_t len, \ |
191 | int behav); } | | 191 | int behav); } |
192 | 76 OBSOL vhangup | | 192 | 76 OBSOL vhangup |
193 | 77 OBSOL vlimit | | 193 | 77 OBSOL vlimit |
194 | 78 STD { int|sys||mincore(void *addr, size_t len, \ | | 194 | 78 STD { int|sys||mincore(void *addr, size_t len, \ |
195 | char *vec); } | | 195 | char *vec); } |
196 | 79 STD RUMP { int|sys||getgroups(int gidsetsize, \ | | 196 | 79 STD RUMP { int|sys||getgroups(int gidsetsize, \ |
197 | gid_t *gidset); } | | 197 | gid_t *gidset); } |
198 | 80 STD RUMP { int|sys||setgroups(int gidsetsize, \ | | 198 | 80 STD RUMP { int|sys||setgroups(int gidsetsize, \ |
199 | const gid_t *gidset); } | | 199 | const gid_t *gidset); } |
200 | 81 STD RUMP { int|sys||getpgrp(void); } | | 200 | 81 STD RUMP { int|sys||getpgrp(void); } |
201 | 82 STD RUMP { int|sys||setpgid(pid_t pid, pid_t pgid); } | | 201 | 82 STD RUMP { int|sys||setpgid(pid_t pid, pid_t pgid); } |
202 | 83 COMPAT_50 MODULAR compat_50 { int|sys||setitimer(int which, \ | | 202 | 83 COMPAT_50 MODULAR compat_50 { int|sys||setitimer(int which, \ |
203 | const struct itimerval50 *itv, \ | | 203 | const struct itimerval50 *itv, \ |
204 | struct itimerval50 *oitv); } | | 204 | struct itimerval50 *oitv); } |
205 | 84 COMPAT_43 MODULAR compat_43 { int|sys||wait(void); } owait | | 205 | 84 COMPAT_43 MODULAR compat_43 { int|sys||wait(void); } owait |
206 | 85 COMPAT_12 MODULAR compat_12 { int|sys||swapon(const char *name); } \ | | 206 | 85 COMPAT_12 MODULAR compat_12 { int|sys||swapon(const char *name); } \ |
207 | oswapon | | 207 | oswapon |
208 | 86 COMPAT_50 MODULAR compat_50 { int|sys||getitimer(int which, \ | | 208 | 86 COMPAT_50 MODULAR compat_50 { int|sys||getitimer(int which, \ |
209 | struct itimerval50 *itv); } | | 209 | struct itimerval50 *itv); } |
210 | 87 COMPAT_43 MODULAR compat_43 \ | | 210 | 87 COMPAT_43 MODULAR compat_43 \ |
211 | { int|sys||gethostname(char *hostname, u_int len); } \ | | 211 | { int|sys||gethostname(char *hostname, u_int len); } \ |
212 | ogethostname | | 212 | ogethostname |
213 | 88 COMPAT_43 MODULAR compat_43 \ | | 213 | 88 COMPAT_43 MODULAR compat_43 \ |
214 | { int|sys||sethostname(char *hostname, u_int len); } \ | | 214 | { int|sys||sethostname(char *hostname, u_int len); } \ |
215 | osethostname | | 215 | osethostname |
216 | 89 COMPAT_43 MODULAR compat_43 \ | | 216 | 89 COMPAT_43 MODULAR compat_43 \ |
217 | { int|sys||getdtablesize(void); } ogetdtablesize | | 217 | { int|sys||getdtablesize(void); } ogetdtablesize |
218 | 90 STD RUMP { int|sys||dup2(int from, int to); } | | 218 | 90 STD RUMP { int|sys||dup2(int from, int to); } |
219 | 91 STD RUMP { ssize_t|sys||getrandom(void *buf, size_t buflen, \ | | 219 | 91 STD RUMP { ssize_t|sys||getrandom(void *buf, size_t buflen, \ |
220 | unsigned int flags); } | | 220 | unsigned int flags); } |
221 | 92 STD RUMP { int|sys||fcntl(int fd, int cmd, ... void *arg); } | | 221 | 92 STD RUMP { int|sys||fcntl(int fd, int cmd, ... void *arg); } |
222 | 93 COMPAT_50 MODULAR compat_50 RUMP \ | | 222 | 93 COMPAT_50 MODULAR compat_50 RUMP \ |
223 | { int|sys||select(int nd, fd_set *in, fd_set *ou, \ | | 223 | { int|sys||select(int nd, fd_set *in, fd_set *ou, \ |
224 | fd_set *ex, struct timeval50 *tv); } | | 224 | fd_set *ex, struct timeval50 *tv); } |
225 | 94 UNIMPL setdopt | | 225 | 94 UNIMPL setdopt |
226 | 95 STD RUMP { int|sys||fsync(int fd); } | | 226 | 95 STD RUMP { int|sys||fsync(int fd); } |
227 | 96 STD { int|sys||setpriority(int which, id_t who, int prio); } | | 227 | 96 STD { int|sys||setpriority(int which, id_t who, int prio); } |
228 | 97 COMPAT_30 MODULAR compat_30 \ | | 228 | 97 COMPAT_30 MODULAR compat_30 \ |
229 | { int|sys||socket(int domain, int type, int protocol); } | | 229 | { int|sys||socket(int domain, int type, int protocol); } |
230 | 98 STD RUMP { int|sys||connect(int s, const struct sockaddr *name, \ | | 230 | 98 STD RUMP { int|sys||connect(int s, const struct sockaddr *name, \ |
231 | socklen_t namelen); } | | 231 | socklen_t namelen); } |
232 | 99 COMPAT_43 MODULAR compat_43 \ | | 232 | 99 COMPAT_43 MODULAR compat_43 \ |
233 | { int|sys||accept(int s, void *name, \ | | 233 | { int|sys||accept(int s, void *name, \ |
234 | socklen_t *anamelen); } oaccept | | 234 | socklen_t *anamelen); } oaccept |
235 | 100 STD { int|sys||getpriority(int which, id_t who); } | | 235 | 100 STD { int|sys||getpriority(int which, id_t who); } |
236 | 101 COMPAT_43 MODULAR compat_43 { int|sys||send(int s, void *buf, int len, \ | | 236 | 101 COMPAT_43 MODULAR compat_43 { int|sys||send(int s, void *buf, int len, \ |
237 | int flags); } osend | | 237 | int flags); } osend |
238 | 102 COMPAT_43 MODULAR compat_43 { int|sys||recv(int s, void *buf, int len, \ | | 238 | 102 COMPAT_43 MODULAR compat_43 { int|sys||recv(int s, void *buf, int len, \ |
239 | int flags); } orecv | | 239 | int flags); } orecv |
240 | 103 COMPAT_13 MODULAR compat_13 \ | | 240 | 103 COMPAT_13 MODULAR compat_13 \ |
241 | { int|sys||sigreturn(struct sigcontext13 *sigcntxp); } \ | | 241 | { int|sys||sigreturn(struct sigcontext13 *sigcntxp); } \ |
242 | sigreturn13 | | 242 | sigreturn13 |
243 | 104 STD RUMP { int|sys||bind(int s, const struct sockaddr *name, \ | | 243 | 104 STD RUMP { int|sys||bind(int s, const struct sockaddr *name, \ |
244 | socklen_t namelen); } | | 244 | socklen_t namelen); } |
245 | 105 STD RUMP { int|sys||setsockopt(int s, int level, int name, \ | | 245 | 105 STD RUMP { int|sys||setsockopt(int s, int level, int name, \ |
246 | const void *val, socklen_t valsize); } | | 246 | const void *val, socklen_t valsize); } |
247 | 106 STD RUMP { int|sys||listen(int s, int backlog); } | | 247 | 106 STD RUMP { int|sys||listen(int s, int backlog); } |
248 | 107 OBSOL vtimes | | 248 | 107 OBSOL vtimes |
249 | 108 COMPAT_43 MODULAR compat_43 \ | | 249 | 108 COMPAT_43 MODULAR compat_43 \ |
250 | { int|sys||sigvec(int signum, struct sigvec *nsv, \ | | 250 | { int|sys||sigvec(int signum, struct sigvec *nsv, \ |
251 | struct sigvec *osv); } osigvec | | 251 | struct sigvec *osv); } osigvec |
252 | 109 COMPAT_43 MODULAR compat { int|sys||sigblock(int mask); } osigblock | | 252 | 109 COMPAT_43 MODULAR compat { int|sys||sigblock(int mask); } osigblock |
253 | 110 COMPAT_43 MODULAR compat { int|sys||sigsetmask(int mask); } osigsetmask | | 253 | 110 COMPAT_43 MODULAR compat { int|sys||sigsetmask(int mask); } osigsetmask |
254 | 111 COMPAT_13 MODULAR compat { int|sys||sigsuspend(int mask); } sigsuspend13 | | 254 | 111 COMPAT_13 MODULAR compat { int|sys||sigsuspend(int mask); } sigsuspend13 |
255 | 112 COMPAT_43 MODULAR compat_43 { int|sys||sigstack(struct sigstack *nss, \ | | 255 | 112 COMPAT_43 MODULAR compat_43 { int|sys||sigstack(struct sigstack *nss, \ |
256 | struct sigstack *oss); } osigstack | | 256 | struct sigstack *oss); } osigstack |
257 | 113 COMPAT_43 MODULAR compat_43 \ | | 257 | 113 COMPAT_43 MODULAR compat_43 \ |
258 | { int|sys||recvmsg(int s, struct omsghdr *msg, \ | | 258 | { int|sys||recvmsg(int s, struct omsghdr *msg, \ |
259 | int flags); } orecvmsg | | 259 | int flags); } orecvmsg |
260 | 114 COMPAT_43 MODULAR compat_43 \ | | 260 | 114 COMPAT_43 MODULAR compat_43 \ |
261 | { int|sys||sendmsg(int s, void *msg, int flags); } osendmsg | | 261 | { int|sys||sendmsg(int s, void *msg, int flags); } osendmsg |
262 | 115 OBSOL vtrace | | 262 | 115 OBSOL vtrace |
263 | 116 COMPAT_50 MODULAR compat_50 \ | | 263 | 116 COMPAT_50 MODULAR compat_50 \ |
264 | { int|sys||gettimeofday(struct timeval50 *tp, void *tzp); } | | 264 | { int|sys||gettimeofday(struct timeval50 *tp, void *tzp); } |
265 | 117 COMPAT_50 MODULAR compat_50 \ | | 265 | 117 COMPAT_50 MODULAR compat_50 \ |
266 | { int|sys||getrusage(int who, struct rusage50 *rusage); } | | 266 | { int|sys||getrusage(int who, struct rusage50 *rusage); } |
267 | 118 STD RUMP { int|sys||getsockopt(int s, int level, int name, \ | | 267 | 118 STD RUMP { int|sys||getsockopt(int s, int level, int name, \ |
268 | void *val, socklen_t *avalsize); } | | 268 | void *val, socklen_t *avalsize); } |
269 | 119 OBSOL resuba | | 269 | 119 OBSOL resuba |
270 | 120 STD RUMP { ssize_t|sys||readv(int fd, \ | | 270 | 120 STD RUMP { ssize_t|sys||readv(int fd, \ |
271 | const struct iovec *iovp, int iovcnt); } | | 271 | const struct iovec *iovp, int iovcnt); } |
272 | 121 STD RUMP { ssize_t|sys||writev(int fd, \ | | 272 | 121 STD RUMP { ssize_t|sys||writev(int fd, \ |
273 | const struct iovec *iovp, int iovcnt); } | | 273 | const struct iovec *iovp, int iovcnt); } |
274 | 122 COMPAT_50 MODULAR compat_50 \ | | 274 | 122 COMPAT_50 MODULAR compat_50 \ |
275 | { int|sys||settimeofday(const struct timeval50 *tv, \ | | 275 | { int|sys||settimeofday(const struct timeval50 *tv, \ |
276 | const void *tzp); } | | 276 | const void *tzp); } |
277 | 123 STD RUMP { int|sys||fchown(int fd, uid_t uid, gid_t gid); } | | 277 | 123 STD RUMP { int|sys||fchown(int fd, uid_t uid, gid_t gid); } |
278 | 124 STD RUMP { int|sys||fchmod(int fd, mode_t mode); } | | 278 | 124 STD RUMP { int|sys||fchmod(int fd, mode_t mode); } |
279 | 125 COMPAT_43 MODULAR compat_43 \ | | 279 | 125 COMPAT_43 MODULAR compat_43 \ |
280 | { int|sys||recvfrom(int s, void *buf, size_t len, \ | | 280 | { int|sys||recvfrom(int s, void *buf, size_t len, \ |
281 | int flags, void *from, socklen_t *fromlenaddr); } \ | | 281 | int flags, void *from, socklen_t *fromlenaddr); } \ |
282 | orecvfrom | | 282 | orecvfrom |
283 | 126 STD RUMP { int|sys||setreuid(uid_t ruid, uid_t euid); } | | 283 | 126 STD RUMP { int|sys||setreuid(uid_t ruid, uid_t euid); } |
284 | 127 STD RUMP { int|sys||setregid(gid_t rgid, gid_t egid); } | | 284 | 127 STD RUMP { int|sys||setregid(gid_t rgid, gid_t egid); } |
285 | 128 STD RUMP { int|sys||rename(const char *from, const char *to); } | | 285 | 128 STD RUMP { int|sys||rename(const char *from, const char *to); } |
286 | 129 COMPAT_43 MODULAR compat_43 \ | | 286 | 129 COMPAT_43 MODULAR compat_43 \ |
287 | { int|sys||truncate(const char *path, long length); } otruncate | | 287 | { int|sys||truncate(const char *path, long length); } otruncate |
288 | 130 COMPAT_43 MODULAR compat_43 \ | | 288 | 130 COMPAT_43 MODULAR compat_43 \ |
289 | { int|sys||ftruncate(int fd, long length); } oftruncate | | 289 | { int|sys||ftruncate(int fd, long length); } oftruncate |
290 | 131 STD RUMP { int|sys||flock(int fd, int how); } | | 290 | 131 STD RUMP { int|sys||flock(int fd, int how); } |
291 | 132 STD RUMP { int|sys||mkfifo(const char *path, mode_t mode); } | | 291 | 132 STD RUMP { int|sys||mkfifo(const char *path, mode_t mode); } |
292 | 133 STD RUMP { ssize_t|sys||sendto(int s, const void *buf, \ | | 292 | 133 STD RUMP { ssize_t|sys||sendto(int s, const void *buf, \ |
293 | size_t len, int flags, const struct sockaddr *to, \ | | 293 | size_t len, int flags, const struct sockaddr *to, \ |
294 | socklen_t tolen); } | | 294 | socklen_t tolen); } |
295 | 134 STD RUMP { int|sys||shutdown(int s, int how); } | | 295 | 134 STD RUMP { int|sys||shutdown(int s, int how); } |
296 | 135 STD RUMP { int|sys||socketpair(int domain, int type, \ | | 296 | 135 STD RUMP { int|sys||socketpair(int domain, int type, \ |
297 | int protocol, int *rsv); } | | 297 | int protocol, int *rsv); } |
298 | 136 STD RUMP { int|sys||mkdir(const char *path, mode_t mode); } | | 298 | 136 STD RUMP { int|sys||mkdir(const char *path, mode_t mode); } |
299 | 137 STD RUMP { int|sys||rmdir(const char *path); } | | 299 | 137 STD RUMP { int|sys||rmdir(const char *path); } |
300 | 138 COMPAT_50 MODULAR compat_50 RUMP { int|sys||utimes(const char *path, \ | | 300 | 138 COMPAT_50 MODULAR compat_50 RUMP { int|sys||utimes(const char *path, \ |
301 | const struct timeval50 *tptr); } | | 301 | const struct timeval50 *tptr); } |
302 | 139 OBSOL 4.2 sigreturn | | 302 | 139 OBSOL 4.2 sigreturn |
303 | 140 COMPAT_50 MODULAR compat_50 \ | | 303 | 140 COMPAT_50 MODULAR compat_50 \ |
304 | { int|sys||adjtime(const struct timeval50 *delta, \ | | 304 | { int|sys||adjtime(const struct timeval50 *delta, \ |
305 | struct timeval50 *olddelta); } | | 305 | struct timeval50 *olddelta); } |
306 | 141 COMPAT_43 MODULAR compat_43 \ | | 306 | 141 COMPAT_43 MODULAR compat_43 \ |
307 | { int|sys||getpeername(int fdes, void *asa, \ | | 307 | { int|sys||getpeername(int fdes, void *asa, \ |
308 | socklen_t *alen); } ogetpeername | | 308 | socklen_t *alen); } ogetpeername |
309 | 142 COMPAT_43 MODULAR compat_43 \ | | 309 | 142 COMPAT_43 MODULAR compat_43 \ |
310 | { int32_t|sys||gethostid(void); } ogethostid | | 310 | { int32_t|sys||gethostid(void); } ogethostid |
311 | 143 COMPAT_43 MODULAR compat_43 \ | | 311 | 143 COMPAT_43 MODULAR compat_43 \ |
312 | { int|sys||sethostid(int32_t hostid); } osethostid | | 312 | { int|sys||sethostid(int32_t hostid); } osethostid |
313 | 144 COMPAT_43 MODULAR compat_43 \ | | 313 | 144 COMPAT_43 MODULAR compat_43 \ |
314 | { int|sys||getrlimit(int which, \ | | 314 | { int|sys||getrlimit(int which, \ |
315 | struct orlimit *rlp); } ogetrlimit | | 315 | struct orlimit *rlp); } ogetrlimit |
316 | 145 COMPAT_43 MODULAR compat_43 { int|sys||setrlimit(int which, \ | | 316 | 145 COMPAT_43 MODULAR compat_43 { int|sys||setrlimit(int which, \ |
317 | const struct orlimit *rlp); } osetrlimit | | 317 | const struct orlimit *rlp); } osetrlimit |
318 | 146 COMPAT_43 MODULAR compat_43 \ | | 318 | 146 COMPAT_43 MODULAR compat_43 \ |
319 | { int|sys||killpg(int pgid, int signum); } okillpg | | 319 | { int|sys||killpg(int pgid, int signum); } okillpg |
320 | 147 STD RUMP { int|sys||setsid(void); } | | 320 | 147 STD RUMP { int|sys||setsid(void); } |
321 | 148 COMPAT_50 MODULAR compat_50_quota \ | | 321 | 148 COMPAT_50 MODULAR compat_50_quota \ |
322 | { int|sys||quotactl(const char *path, \ | | 322 | { int|sys||quotactl(const char *path, \ |
323 | int cmd, int uid, void *arg); } | | 323 | int cmd, int uid, void *arg); } |
324 | 149 COMPAT_43 MODULAR compat_43 { int|sys||quota(void); } oquota | | 324 | 149 COMPAT_43 MODULAR compat_43 { int|sys||quota(void); } oquota |
325 | 150 COMPAT_43 MODULAR compat_43 { int|sys||getsockname(int fdec, \ | | 325 | 150 COMPAT_43 MODULAR compat_43 { int|sys||getsockname(int fdec, \ |
326 | void *asa, socklen_t *alen); } ogetsockname | | 326 | void *asa, socklen_t *alen); } ogetsockname |
327 | | | 327 | |
328 | ; Syscalls 151-180 inclusive are reserved for vendor-specific | | 328 | ; Syscalls 151-180 inclusive are reserved for vendor-specific |
329 | ; system calls. (This includes various calls added for compatibity | | 329 | ; system calls. (This includes various calls added for compatibity |
330 | ; with other Unix variants.) | | 330 | ; with other Unix variants.) |
331 | ; Some of these calls are now supported by BSD... | | 331 | ; Some of these calls are now supported by BSD... |
332 | 151 UNIMPL | | 332 | 151 UNIMPL |
333 | 152 UNIMPL | | 333 | 152 UNIMPL |
334 | 153 UNIMPL | | 334 | 153 UNIMPL |
335 | 154 UNIMPL | | 335 | 154 UNIMPL |
336 | 155 STD MODULAR nfsserver RUMP { int|sys||nfssvc(int flag, void *argp); } | | 336 | 155 STD MODULAR nfsserver RUMP { int|sys||nfssvc(int flag, void *argp); } |
337 | 156 COMPAT_43 MODULAR compat_43 \ | | 337 | 156 COMPAT_43 MODULAR compat_43 \ |
338 | { int|sys||getdirentries(int fd, char *buf, \ | | 338 | { int|sys||getdirentries(int fd, char *buf, \ |
339 | u_int count, long *basep); } ogetdirentries | | 339 | u_int count, long *basep); } ogetdirentries |
340 | 157 COMPAT_20 MODULAR compat_20 { int|sys||statfs(const char *path, \ | | 340 | 157 COMPAT_20 MODULAR compat_20 { int|sys||statfs(const char *path, \ |
341 | struct statfs12 *buf); } | | 341 | struct statfs12 *buf); } |
342 | 158 COMPAT_20 MODULAR compat_20 \ | | 342 | 158 COMPAT_20 MODULAR compat_20 \ |
343 | { int|sys||fstatfs(int fd, struct statfs12 *buf); } | | 343 | { int|sys||fstatfs(int fd, struct statfs12 *buf); } |
344 | 159 UNIMPL | | 344 | 159 UNIMPL |
345 | 160 UNIMPL | | 345 | 160 UNIMPL |
346 | 161 COMPAT_30 MODULAR compat_30 { int|sys||getfh(const char *fname, \ | | 346 | 161 COMPAT_30 MODULAR compat_30 { int|sys||getfh(const char *fname, \ |
347 | struct compat_30_fhandle *fhp); } | | 347 | struct compat_30_fhandle *fhp); } |
348 | 162 COMPAT_09 MODULAR compat_09 \ | | 348 | 162 COMPAT_09 MODULAR compat_09 \ |
349 | { int|sys||getdomainname(char *domainname, int len); } \ | | 349 | { int|sys||getdomainname(char *domainname, int len); } \ |
350 | ogetdomainname | | 350 | ogetdomainname |
351 | 163 COMPAT_09 MODULAR compat_09 \ | | 351 | 163 COMPAT_09 MODULAR compat_09 \ |
352 | { int|sys||setdomainname(char *domainname, int len); } \ | | 352 | { int|sys||setdomainname(char *domainname, int len); } \ |
353 | osetdomainname | | 353 | osetdomainname |
354 | 164 COMPAT_09 MODULAR compat \ | | 354 | 164 COMPAT_09 MODULAR compat \ |
355 | { int|sys||uname(struct outsname *name); } ouname | | 355 | { int|sys||uname(struct outsname *name); } ouname |
356 | 165 STD { int|sys||sysarch(int op, void *parms); } | | 356 | 165 STD { int|sys||sysarch(int op, void *parms); } |
357 | 166 STD { int|sys||__futex(int *uaddr, int op, int val, \ | | 357 | 166 STD { int|sys||__futex(int *uaddr, int op, int val, \ |
358 | const struct timespec *timeout, \ | | 358 | const struct timespec *timeout, \ |
359 | int *uaddr2, int val2, int val3); } | | 359 | int *uaddr2, int val2, int val3); } |
360 | 167 STD { int|sys||__futex_set_robust_list(void *head, \ | | 360 | 167 STD { int|sys||__futex_set_robust_list(void *head, \ |
361 | size_t len); } | | 361 | size_t len); } |
362 | 168 STD { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ | | 362 | 168 STD { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ |
363 | void **headp, size_t *lenp); } | | 363 | void **headp, size_t *lenp); } |
364 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) | | 364 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) |
365 | #if !defined(_LP64) | | 365 | #if !defined(_LP64) |
366 | 169 COMPAT_10 MODULAR compat_sysv_10 \ | | 366 | 169 COMPAT_10 MODULAR compat_sysv_10 \ |
367 | { int|sys||semsys(int which, int a2, int a3, int a4, \ | | 367 | { int|sys||semsys(int which, int a2, int a3, int a4, \ |
368 | int a5); } osemsys | | 368 | int a5); } osemsys |
369 | #else | | 369 | #else |
370 | 169 EXCL 1.0 semsys | | 370 | 169 EXCL 1.0 semsys |
371 | #endif | | 371 | #endif |
372 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) | | 372 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) |
373 | #if !defined(_LP64) | | 373 | #if !defined(_LP64) |
374 | 170 COMPAT_10 MODULAR compat_sysv_10 \ | | 374 | 170 COMPAT_10 MODULAR compat_sysv_10 \ |
375 | { int|sys||msgsys(int which, int a2, int a3, int a4, \ | | 375 | { int|sys||msgsys(int which, int a2, int a3, int a4, \ |
376 | int a5, int a6); } omsgsys | | 376 | int a5, int a6); } omsgsys |
377 | #else | | 377 | #else |
378 | 170 EXCL 1.0 msgsys | | 378 | 170 EXCL 1.0 msgsys |
379 | #endif | | 379 | #endif |
380 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) | | 380 | ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) |
381 | #if !defined(_LP64) | | 381 | #if !defined(_LP64) |
382 | 171 COMPAT_10 MODULAR compat_sysv_10 \ | | 382 | 171 COMPAT_10 MODULAR compat_sysv_10 \ |
383 | { int|sys||shmsys(int which, int a2, int a3, int a4); } \ | | 383 | { int|sys||shmsys(int which, int a2, int a3, int a4); } \ |
384 | oshmsys | | 384 | oshmsys |
385 | #else | | 385 | #else |
386 | 171 EXCL 1.0 shmsys | | 386 | 171 EXCL 1.0 shmsys |
387 | #endif | | 387 | #endif |
388 | 172 UNIMPL | | 388 | 172 UNIMPL |
389 | 173 STD RUMP { ssize_t|sys||pread(int fd, void *buf, \ | | 389 | 173 STD RUMP { ssize_t|sys||pread(int fd, void *buf, \ |
390 | size_t nbyte, int PAD, off_t offset); } | | 390 | size_t nbyte, int PAD, off_t offset); } |
391 | 174 STD RUMP { ssize_t|sys||pwrite(int fd, const void *buf, \ | | 391 | 174 STD RUMP { ssize_t|sys||pwrite(int fd, const void *buf, \ |
392 | size_t nbyte, int PAD, off_t offset); } | | 392 | size_t nbyte, int PAD, off_t offset); } |
393 | ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded. | | 393 | ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded. |
394 | 175 COMPAT_30 MODULAR compat_30 \ | | 394 | 175 COMPAT_30 MODULAR compat_30 \ |
395 | { int|sys||ntp_gettime(struct ntptimeval30 *ntvp); } | | 395 | { int|sys||ntp_gettime(struct ntptimeval30 *ntvp); } |
396 | #if defined(NTP) || !defined(_KERNEL_OPT) | | 396 | #if defined(NTP) || !defined(_KERNEL_OPT) |
397 | 176 STD { int|sys||ntp_adjtime(struct timex *tp); } | | 397 | 176 STD { int|sys||ntp_adjtime(struct timex *tp); } |
398 | #else | | 398 | #else |
399 | 176 EXCL ntp_adjtime | | 399 | 176 EXCL ntp_adjtime |
400 | #endif | | 400 | #endif |
401 | 177 UNIMPL | | 401 | 177 UNIMPL |
402 | 178 UNIMPL | | 402 | 178 UNIMPL |
403 | 179 UNIMPL | | 403 | 179 UNIMPL |
404 | 180 UNIMPL | | 404 | 180 UNIMPL |
405 | | | 405 | |
406 | ; Syscalls 180-199 are used by/reserved for BSD | | 406 | ; Syscalls 180-199 are used by/reserved for BSD |
407 | 181 STD RUMP { int|sys||setgid(gid_t gid); } | | 407 | 181 STD RUMP { int|sys||setgid(gid_t gid); } |
408 | 182 STD RUMP { int|sys||setegid(gid_t egid); } | | 408 | 182 STD RUMP { int|sys||setegid(gid_t egid); } |
409 | 183 STD RUMP { int|sys||seteuid(uid_t euid); } | | 409 | 183 STD RUMP { int|sys||seteuid(uid_t euid); } |
410 | 184 STD MODULAR lfs { int|sys||lfs_bmapv(fsid_t *fsidp, \ | | 410 | 184 STD MODULAR lfs { int|sys||lfs_bmapv(fsid_t *fsidp, \ |
411 | struct block_info *blkiov, int blkcnt); } | | 411 | struct block_info *blkiov, int blkcnt); } |
412 | 185 STD MODULAR lfs { int|sys||lfs_markv(fsid_t *fsidp, \ | | 412 | 185 STD MODULAR lfs { int|sys||lfs_markv(fsid_t *fsidp, \ |
413 | struct block_info *blkiov, int blkcnt); } | | 413 | struct block_info *blkiov, int blkcnt); } |
414 | 186 STD MODULAR lfs { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); } | | 414 | 186 STD MODULAR lfs { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); } |
415 | 187 COMPAT_50 MODULAR compat_50 { int|sys||lfs_segwait(fsid_t *fsidp, \ | | 415 | 187 COMPAT_50 MODULAR compat_50 { int|sys||lfs_segwait(fsid_t *fsidp, \ |
416 | struct timeval50 *tv); } | | 416 | struct timeval50 *tv); } |
417 | 188 COMPAT_12 MODULAR compat_12 \ | | 417 | 188 COMPAT_12 MODULAR compat_12 \ |
418 | { int|sys||stat(const char *path, struct stat12 *ub); } stat12 | | 418 | { int|sys||stat(const char *path, struct stat12 *ub); } stat12 |
419 | 189 COMPAT_12 MODULAR compat_12 \ | | 419 | 189 COMPAT_12 MODULAR compat_12 \ |
420 | { int|sys||fstat(int fd, struct stat12 *sb); } fstat12 | | 420 | { int|sys||fstat(int fd, struct stat12 *sb); } fstat12 |
421 | 190 COMPAT_12 MODULAR compat_12 { int|sys||lstat(const char *path, \ | | 421 | 190 COMPAT_12 MODULAR compat_12 { int|sys||lstat(const char *path, \ |
422 | struct stat12 *ub); } lstat12 | | 422 | struct stat12 *ub); } lstat12 |
423 | 191 STD RUMP { long|sys||pathconf(const char *path, int name); } | | 423 | 191 STD RUMP { long|sys||pathconf(const char *path, int name); } |
424 | 192 STD RUMP { long|sys||fpathconf(int fd, int name); } | | 424 | 192 STD RUMP { long|sys||fpathconf(int fd, int name); } |
425 | 193 STD RUMP { int|sys||getsockopt2(int s, int level, int name, \ | | 425 | 193 STD RUMP { int|sys||getsockopt2(int s, int level, int name, \ |
426 | void *val, socklen_t *avalsize); } | | 426 | void *val, socklen_t *avalsize); } |
427 | 194 STD RUMP { int|sys||getrlimit(int which, \ | | 427 | 194 STD RUMP { int|sys||getrlimit(int which, \ |
428 | struct rlimit *rlp); } | | 428 | struct rlimit *rlp); } |
429 | 195 STD RUMP { int|sys||setrlimit(int which, \ | | 429 | 195 STD RUMP { int|sys||setrlimit(int which, \ |
430 | const struct rlimit *rlp); } | | 430 | const struct rlimit *rlp); } |
431 | 196 COMPAT_12 MODULAR compat_12 \ | | 431 | 196 COMPAT_12 MODULAR compat_12 \ |
432 | { int|sys||getdirentries(int fd, char *buf, \ | | 432 | { int|sys||getdirentries(int fd, char *buf, \ |
433 | u_int count, long *basep); } | | 433 | u_int count, long *basep); } |
434 | 197 STD { void *|sys||mmap(void *addr, size_t len, int prot, \ | | 434 | 197 STD { void *|sys||mmap(void *addr, size_t len, int prot, \ |
435 | int flags, int fd, long PAD, off_t pos); } | | 435 | int flags, int fd, long PAD, off_t pos); } |
436 | 198 INDIR { quad_t|sys||__syscall(quad_t code, \ | | 436 | 198 INDIR { quad_t|sys||__syscall(quad_t code, \ |
437 | ... register_t args[SYS_MAXSYSARGS]); } | | 437 | ... register_t args[SYS_MAXSYSARGS]); } |
438 | 199 STD RUMP { off_t|sys||lseek(int fd, int PAD, off_t offset, \ | | 438 | 199 STD RUMP { off_t|sys||lseek(int fd, int PAD, off_t offset, \ |
439 | int whence); } | | 439 | int whence); } |
440 | 200 STD RUMP { int|sys||truncate(const char *path, int PAD, \ | | 440 | 200 STD RUMP { int|sys||truncate(const char *path, int PAD, \ |
441 | off_t length); } | | 441 | off_t length); } |
442 | 201 STD RUMP { int|sys||ftruncate(int fd, int PAD, off_t length); } | | 442 | 201 STD RUMP { int|sys||ftruncate(int fd, int PAD, off_t length); } |
443 | 202 STD RUMP { int|sys||__sysctl(const int *name, u_int namelen, \ | | 443 | 202 STD RUMP { int|sys||__sysctl(const int *name, u_int namelen, \ |
444 | void *oldv, size_t *oldlenp, const void *newv, \ | | 444 | void *oldv, size_t *oldlenp, const void *newv, \ |
445 | size_t newlen); } | | 445 | size_t newlen); } |
446 | 203 STD { int|sys||mlock(const void *addr, size_t len); } | | 446 | 203 STD { int|sys||mlock(const void *addr, size_t len); } |
447 | 204 STD { int|sys||munlock(const void *addr, size_t len); } | | 447 | 204 STD { int|sys||munlock(const void *addr, size_t len); } |
448 | 205 STD { int|sys||undelete(const char *path); } | | 448 | 205 STD { int|sys||undelete(const char *path); } |
449 | 206 COMPAT_50 MODULAR compat_50 RUMP { int|sys||futimes(int fd, \ | | 449 | 206 COMPAT_50 MODULAR compat_50 RUMP { int|sys||futimes(int fd, \ |
450 | const struct timeval50 *tptr); } | | 450 | const struct timeval50 *tptr); } |
451 | 207 STD RUMP { pid_t|sys||getpgid(pid_t pid); } | | 451 | 207 STD RUMP { pid_t|sys||getpgid(pid_t pid); } |
452 | 208 STD RUMP { int|sys||reboot(int opt, char *bootstr); } | | 452 | 208 STD RUMP { int|sys||reboot(int opt, char *bootstr); } |
453 | 209 STD RUMP { int|sys||poll(struct pollfd *fds, u_int nfds, \ | | 453 | 209 STD RUMP { int|sys||poll(struct pollfd *fds, u_int nfds, \ |
454 | int timeout); } | | 454 | int timeout); } |
455 | ; | | 455 | ; |
456 | ; Syscalls 210-219 are reserved for dynamically loaded syscalls | | 456 | ; Syscalls 210-219 are reserved for dynamically loaded syscalls |
457 | ; | | 457 | ; |
458 | 210 EXTERN MODULAR openafs { int|sys||afssys(long id, long a1, long a2, \ | | 458 | 210 EXTERN MODULAR openafs { int|sys||afssys(long id, long a1, long a2, \ |
459 | long a3, long a4, long a5, long a6); } | | 459 | long a3, long a4, long a5, long a6); } |
460 | 211 UNIMPL | | 460 | 211 UNIMPL |
461 | 212 UNIMPL | | 461 | 212 UNIMPL |
462 | 213 UNIMPL | | 462 | 213 UNIMPL |
463 | 214 UNIMPL | | 463 | 214 UNIMPL |
464 | 215 UNIMPL | | 464 | 215 UNIMPL |
465 | 216 UNIMPL | | 465 | 216 UNIMPL |
466 | 217 UNIMPL | | 466 | 217 UNIMPL |
467 | 218 UNIMPL | | 467 | 218 UNIMPL |
468 | 219 UNIMPL | | 468 | 219 UNIMPL |
469 | ; System calls 220-300 are reserved for use by NetBSD | | 469 | ; System calls 220-300 are reserved for use by NetBSD |
470 | 220 COMPAT_14 MODULAR compat_sysv_14 \ | | 470 | 220 COMPAT_14 MODULAR compat_sysv_14 \ |
471 | { int|sys||__semctl(int semid, int semnum, int cmd, \ | | 471 | { int|sys||__semctl(int semid, int semnum, int cmd, \ |
472 | union __semun *arg); } | | 472 | union __semun *arg); } |
473 | 221 STD MODULAR sysv_ipc { int|sys||semget(key_t key, int nsems, \ | | 473 | 221 STD MODULAR sysv_ipc { int|sys||semget(key_t key, int nsems, \ |
474 | int semflg); } | | 474 | int semflg); } |
475 | 222 STD MODULAR sysv_ipc { int|sys||semop(int semid, struct sembuf *sops, \ | | 475 | 222 STD MODULAR sysv_ipc { int|sys||semop(int semid, struct sembuf *sops, \ |
476 | size_t nsops); } | | 476 | size_t nsops); } |
477 | 223 STD MODULAR sysv_ipc { int|sys||semconfig(int flag); } | | 477 | 223 STD MODULAR sysv_ipc { int|sys||semconfig(int flag); } |
478 | 224 COMPAT_14 MODULAR compat_sysv_14 { int|sys||msgctl(int msqid, int cmd, \ | | 478 | 224 COMPAT_14 MODULAR compat_sysv_14 { int|sys||msgctl(int msqid, int cmd, \ |
479 | struct msqid_ds14 *buf); } | | 479 | struct msqid_ds14 *buf); } |
480 | 225 STD MODULAR sysv_ipc { int|sys||msgget(key_t key, int msgflg); } | | 480 | 225 STD MODULAR sysv_ipc { int|sys||msgget(key_t key, int msgflg); } |
481 | 226 STD MODULAR sysv_ipc { int|sys||msgsnd(int msqid, const void *msgp, \ | | 481 | 226 STD MODULAR sysv_ipc { int|sys||msgsnd(int msqid, const void *msgp, \ |
482 | size_t msgsz, int msgflg); } | | 482 | size_t msgsz, int msgflg); } |
483 | 227 STD MODULAR sysv_ipc { ssize_t|sys||msgrcv(int msqid, void *msgp, \ | | 483 | 227 STD MODULAR sysv_ipc { ssize_t|sys||msgrcv(int msqid, void *msgp, \ |
484 | size_t msgsz, long msgtyp, int msgflg); } | | 484 | size_t msgsz, long msgtyp, int msgflg); } |
485 | 228 STD MODULAR sysv_ipc { void *|sys||shmat(int shmid, \ | | 485 | 228 STD MODULAR sysv_ipc { void *|sys||shmat(int shmid, \ |
486 | const void *shmaddr, int shmflg); } | | 486 | const void *shmaddr, int shmflg); } |
487 | 229 COMPAT_14 MODULAR compat_sysv_14 { int|sys||shmctl(int shmid, int cmd, \ | | 487 | 229 COMPAT_14 MODULAR compat_sysv_14 { int|sys||shmctl(int shmid, int cmd, \ |
488 | struct shmid_ds14 *buf); } | | 488 | struct shmid_ds14 *buf); } |
489 | 230 STD MODULAR sysv_ipc { int|sys||shmdt(const void *shmaddr); } | | 489 | 230 STD MODULAR sysv_ipc { int|sys||shmdt(const void *shmaddr); } |
490 | 231 STD MODULAR sysv_ipc { int|sys||shmget(key_t key, size_t size, \ | | 490 | 231 STD MODULAR sysv_ipc { int|sys||shmget(key_t key, size_t size, \ |
491 | int shmflg); } | | 491 | int shmflg); } |
492 | 232 COMPAT_50 MODULAR compat_50 \ | | 492 | 232 COMPAT_50 MODULAR compat_50 \ |
493 | { int|sys||clock_gettime(clockid_t clock_id, \ | | 493 | { int|sys||clock_gettime(clockid_t clock_id, \ |
494 | struct timespec50 *tp); } | | 494 | struct timespec50 *tp); } |
495 | 233 COMPAT_50 MODULAR compat_50 \ | | 495 | 233 COMPAT_50 MODULAR compat_50 \ |
496 | { int|sys||clock_settime(clockid_t clock_id, \ | | 496 | { int|sys||clock_settime(clockid_t clock_id, \ |
497 | const struct timespec50 *tp); } | | 497 | const struct timespec50 *tp); } |
498 | 234 COMPAT_50 MODULAR compat_50 \ | | 498 | 234 COMPAT_50 MODULAR compat_50 \ |
499 | { int|sys||clock_getres(clockid_t clock_id, \ | | 499 | { int|sys||clock_getres(clockid_t clock_id, \ |
500 | struct timespec50 *tp); } | | 500 | struct timespec50 *tp); } |
501 | 235 STD RUMP { int|sys||timer_create(clockid_t clock_id, \ | | 501 | 235 STD RUMP { int|sys||timer_create(clockid_t clock_id, \ |
502 | struct sigevent *evp, timer_t *timerid); } | | 502 | struct sigevent *evp, timer_t *timerid); } |
503 | 236 STD RUMP { int|sys||timer_delete(timer_t timerid); } | | 503 | 236 STD RUMP { int|sys||timer_delete(timer_t timerid); } |
504 | 237 COMPAT_50 MODULAR compat_50 { int|sys||timer_settime(timer_t timerid, \ | | 504 | 237 COMPAT_50 MODULAR compat_50 { int|sys||timer_settime(timer_t timerid, \ |
505 | int flags, const struct itimerspec50 *value, \ | | 505 | int flags, const struct itimerspec50 *value, \ |
506 | struct itimerspec50 *ovalue); } | | 506 | struct itimerspec50 *ovalue); } |
507 | 238 COMPAT_50 MODULAR compat_50 { int|sys||timer_gettime(timer_t timerid, \ | | 507 | 238 COMPAT_50 MODULAR compat_50 { int|sys||timer_gettime(timer_t timerid, \ |
508 | struct itimerspec50 *value); } | | 508 | struct itimerspec50 *value); } |
509 | 239 STD RUMP { int|sys||timer_getoverrun(timer_t timerid); } | | 509 | 239 STD RUMP { int|sys||timer_getoverrun(timer_t timerid); } |
510 | ; | | 510 | ; |
511 | ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls | | 511 | ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls |
512 | ; | | 512 | ; |
513 | 240 COMPAT_50 MODULAR compat_50 \ | | 513 | 240 COMPAT_50 MODULAR compat_50 \ |
514 | { int|sys||nanosleep(const struct timespec50 *rqtp, \ | | 514 | { int|sys||nanosleep(const struct timespec50 *rqtp, \ |
515 | struct timespec50 *rmtp); } | | 515 | struct timespec50 *rmtp); } |
516 | 241 STD RUMP { int|sys||fdatasync(int fd); } | | 516 | 241 STD RUMP { int|sys||fdatasync(int fd); } |
517 | 242 STD { int|sys||mlockall(int flags); } | | 517 | 242 STD { int|sys||mlockall(int flags); } |
518 | 243 STD { int|sys||munlockall(void); } | | 518 | 243 STD { int|sys||munlockall(void); } |
519 | 244 COMPAT_50 MODULAR compat_50 \ | | 519 | 244 COMPAT_50 MODULAR compat_50 \ |
520 | { int|sys||__sigtimedwait(const sigset_t *set, \ | | 520 | { int|sys||__sigtimedwait(const sigset_t *set, \ |
521 | siginfo_t *info, struct timespec50 *timeout); } | | 521 | siginfo_t *info, struct timespec50 *timeout); } |
522 | 245 STD { int|sys||sigqueueinfo(pid_t pid, \ | | 522 | 245 STD { int|sys||sigqueueinfo(pid_t pid, \ |
523 | const siginfo_t *info); } | | 523 | const siginfo_t *info); } |
524 | 246 STD RUMP { int|sys||modctl(int cmd, void *arg); } | | 524 | 246 STD RUMP { int|sys||modctl(int cmd, void *arg); } |
525 | 247 STD MODULAR ksem RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); } | | 525 | 247 STD MODULAR ksem RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); } |
526 | 248 STD MODULAR ksem RUMP { int|sys||_ksem_open(const char *name, int oflag, \ | | 526 | 248 STD MODULAR ksem RUMP { int|sys||_ksem_open(const char *name, int oflag, \ |
527 | mode_t mode, unsigned int value, intptr_t *idp); } | | 527 | mode_t mode, unsigned int value, intptr_t *idp); } |
528 | 249 STD MODULAR ksem RUMP { int|sys||_ksem_unlink(const char *name); } | | 528 | 249 STD MODULAR ksem RUMP { int|sys||_ksem_unlink(const char *name); } |
529 | 250 STD MODULAR ksem RUMP { int|sys||_ksem_close(intptr_t id); } | | 529 | 250 STD MODULAR ksem RUMP { int|sys||_ksem_close(intptr_t id); } |
530 | 251 STD MODULAR ksem RUMP { int|sys||_ksem_post(intptr_t id); } | | 530 | 251 STD MODULAR ksem RUMP { int|sys||_ksem_post(intptr_t id); } |
531 | 252 STD MODULAR ksem RUMP { int|sys||_ksem_wait(intptr_t id); } | | 531 | 252 STD MODULAR ksem RUMP { int|sys||_ksem_wait(intptr_t id); } |
532 | 253 STD MODULAR ksem RUMP { int|sys||_ksem_trywait(intptr_t id); } | | 532 | 253 STD MODULAR ksem RUMP { int|sys||_ksem_trywait(intptr_t id); } |
533 | 254 STD MODULAR ksem RUMP { int|sys||_ksem_getvalue(intptr_t id, \ | | 533 | 254 STD MODULAR ksem RUMP { int|sys||_ksem_getvalue(intptr_t id, \ |
534 | unsigned int *value); } | | 534 | unsigned int *value); } |
535 | 255 STD MODULAR ksem RUMP { int|sys||_ksem_destroy(intptr_t id); } | | 535 | 255 STD MODULAR ksem RUMP { int|sys||_ksem_destroy(intptr_t id); } |
536 | 256 STD MODULAR ksem RUMP { int|sys||_ksem_timedwait(intptr_t id, \ | | 536 | 256 STD MODULAR ksem RUMP { int|sys||_ksem_timedwait(intptr_t id, \ |
537 | const struct timespec *abstime); } | | 537 | const struct timespec *abstime); } |
538 | 257 STD MODULAR mqueue \ | | 538 | 257 STD MODULAR mqueue \ |
539 | { mqd_t|sys||mq_open(const char * name, int oflag, \ | | 539 | { mqd_t|sys||mq_open(const char * name, int oflag, \ |
540 | mode_t mode, struct mq_attr *attr); } | | 540 | mode_t mode, struct mq_attr *attr); } |
541 | 258 STD MODULAR mqueue { int|sys||mq_close(mqd_t mqdes); } | | 541 | 258 STD MODULAR mqueue { int|sys||mq_close(mqd_t mqdes); } |
542 | 259 STD MODULAR mqueue { int|sys||mq_unlink(const char *name); } | | 542 | 259 STD MODULAR mqueue { int|sys||mq_unlink(const char *name); } |
543 | 260 STD MODULAR mqueue \ | | 543 | 260 STD MODULAR mqueue \ |
544 | { int|sys||mq_getattr(mqd_t mqdes, \ | | 544 | { int|sys||mq_getattr(mqd_t mqdes, \ |
545 | struct mq_attr *mqstat); } | | 545 | struct mq_attr *mqstat); } |
546 | 261 STD MODULAR mqueue \ | | 546 | 261 STD MODULAR mqueue \ |
547 | { int|sys||mq_setattr(mqd_t mqdes, \ | | 547 | { int|sys||mq_setattr(mqd_t mqdes, \ |
548 | const struct mq_attr *mqstat, \ | | 548 | const struct mq_attr *mqstat, \ |
549 | struct mq_attr *omqstat); } | | 549 | struct mq_attr *omqstat); } |
550 | 262 STD MODULAR mqueue \ | | 550 | 262 STD MODULAR mqueue \ |
551 | { int|sys||mq_notify(mqd_t mqdes, \ | | 551 | { int|sys||mq_notify(mqd_t mqdes, \ |
552 | const struct sigevent *notification); } | | 552 | const struct sigevent *notification); } |
553 | 263 STD MODULAR mqueue \ | | 553 | 263 STD MODULAR mqueue \ |
554 | { int|sys||mq_send(mqd_t mqdes, const char *msg_ptr, \ | | 554 | { int|sys||mq_send(mqd_t mqdes, const char *msg_ptr, \ |
555 | size_t msg_len, unsigned msg_prio); } | | 555 | size_t msg_len, unsigned msg_prio); } |
556 | 264 STD MODULAR mqueue \ | | 556 | 264 STD MODULAR mqueue \ |
557 | { ssize_t|sys||mq_receive(mqd_t mqdes, char *msg_ptr, \ | | 557 | { ssize_t|sys||mq_receive(mqd_t mqdes, char *msg_ptr, \ |
558 | size_t msg_len, unsigned *msg_prio); } | | 558 | size_t msg_len, unsigned *msg_prio); } |
559 | 265 COMPAT_50 MODULAR compat_50 \ | | 559 | 265 COMPAT_50 MODULAR compat_50 \ |
560 | { int|sys||mq_timedsend(mqd_t mqdes, \ | | 560 | { int|sys||mq_timedsend(mqd_t mqdes, \ |
561 | const char *msg_ptr, size_t msg_len, \ | | 561 | const char *msg_ptr, size_t msg_len, \ |
562 | unsigned msg_prio, \ | | 562 | unsigned msg_prio, \ |
563 | const struct timespec50 *abs_timeout); } | | 563 | const struct timespec50 *abs_timeout); } |
564 | 266 COMPAT_50 MODULAR compat_50 \ | | 564 | 266 COMPAT_50 MODULAR compat_50 \ |
565 | { ssize_t|sys||mq_timedreceive(mqd_t mqdes, \ | | 565 | { ssize_t|sys||mq_timedreceive(mqd_t mqdes, \ |
566 | char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ | | 566 | char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ |
567 | const struct timespec50 *abs_timeout); } | | 567 | const struct timespec50 *abs_timeout); } |
568 | 267 UNIMPL | | 568 | 267 UNIMPL |
569 | 268 UNIMPL | | 569 | 268 UNIMPL |
570 | 269 UNIMPL | | 570 | 269 UNIMPL |
571 | 270 STD RUMP { int|sys||__posix_rename(const char *from, \ | | 571 | 270 STD RUMP { int|sys||__posix_rename(const char *from, \ |
572 | const char *to); } | | 572 | const char *to); } |
573 | 271 STD { int|sys||swapctl(int cmd, void *arg, int misc); } | | 573 | 271 STD { int|sys||swapctl(int cmd, void *arg, int misc); } |
574 | 272 COMPAT_30 MODULAR compat_30 \ | | 574 | 272 COMPAT_30 MODULAR compat_30 \ |
575 | { int|sys||getdents(int fd, char *buf, size_t count); } | | 575 | { int|sys||getdents(int fd, char *buf, size_t count); } |
576 | 273 STD { int|sys||minherit(void *addr, size_t len, \ | | 576 | 273 STD { int|sys||minherit(void *addr, size_t len, \ |
577 | int inherit); } | | 577 | int inherit); } |
578 | 274 STD RUMP { int|sys||lchmod(const char *path, mode_t mode); } | | 578 | 274 STD RUMP { int|sys||lchmod(const char *path, mode_t mode); } |
579 | 275 STD RUMP { int|sys||lchown(const char *path, uid_t uid, \ | | 579 | 275 STD RUMP { int|sys||lchown(const char *path, uid_t uid, \ |
580 | gid_t gid); } | | 580 | gid_t gid); } |
581 | 276 COMPAT_50 MODULAR compat_50 RUMP { int|sys||lutimes(const char *path, \ | | 581 | 276 COMPAT_50 MODULAR compat_50 RUMP { int|sys||lutimes(const char *path, \ |
582 | const struct timeval50 *tptr); } | | 582 | const struct timeval50 *tptr); } |
583 | 277 STD { int|sys|13|msync(void *addr, size_t len, int flags); } | | 583 | 277 STD { int|sys|13|msync(void *addr, size_t len, int flags); } |
584 | 278 COMPAT_30 MODULAR compat_30 \ | | 584 | 278 COMPAT_30 MODULAR compat_30 \ |
585 | { int|sys|13|stat(const char *path, struct stat13 *ub); } | | 585 | { int|sys|13|stat(const char *path, struct stat13 *ub); } |
586 | 279 COMPAT_30 MODULAR compat_30 \ | | 586 | 279 COMPAT_30 MODULAR compat_30 \ |
587 | { int|sys|13|fstat(int fd, struct stat13 *sb); } | | 587 | { int|sys|13|fstat(int fd, struct stat13 *sb); } |
588 | 280 COMPAT_30 MODULAR compat_30 \ | | 588 | 280 COMPAT_30 MODULAR compat_30 \ |
589 | { int|sys|13|lstat(const char *path, struct stat13 *ub); } | | 589 | { int|sys|13|lstat(const char *path, struct stat13 *ub); } |
590 | 281 STD { int|sys|14|sigaltstack( \ | | 590 | 281 STD { int|sys|14|sigaltstack( \ |
591 | const struct sigaltstack *nss, \ | | 591 | const struct sigaltstack *nss, \ |
592 | struct sigaltstack *oss); } | | 592 | struct sigaltstack *oss); } |
593 | 282 STD { int|sys|14|vfork(void); } | | 593 | 282 STD { int|sys|14|vfork(void); } |
594 | 283 STD RUMP { int|sys||__posix_chown(const char *path, uid_t uid, \ | | 594 | 283 STD RUMP { int|sys||__posix_chown(const char *path, uid_t uid, \ |
595 | gid_t gid); } | | 595 | gid_t gid); } |
596 | 284 STD RUMP { int|sys||__posix_fchown(int fd, uid_t uid, \ | | 596 | 284 STD RUMP { int|sys||__posix_fchown(int fd, uid_t uid, \ |
597 | gid_t gid); } | | 597 | gid_t gid); } |
598 | 285 STD RUMP { int|sys||__posix_lchown(const char *path, uid_t uid, \ | | 598 | 285 STD RUMP { int|sys||__posix_lchown(const char *path, uid_t uid, \ |
599 | gid_t gid); } | | 599 | gid_t gid); } |
600 | 286 STD RUMP { pid_t|sys||getsid(pid_t pid); } | | 600 | 286 STD RUMP { pid_t|sys||getsid(pid_t pid); } |
601 | 287 STD { pid_t|sys||__clone(int flags, void *stack); } | | 601 | 287 STD { pid_t|sys||__clone(int flags, void *stack); } |
602 | 288 STD RUMP { int|sys||fktrace(int fd, int ops, \ | | 602 | 288 STD RUMP { int|sys||fktrace(int fd, int ops, \ |
603 | int facs, pid_t pid); } | | 603 | int facs, pid_t pid); } |
604 | 289 STD RUMP { ssize_t|sys||preadv(int fd, \ | | 604 | 289 STD RUMP { ssize_t|sys||preadv(int fd, \ |
605 | const struct iovec *iovp, int iovcnt, \ | | 605 | const struct iovec *iovp, int iovcnt, \ |
606 | int PAD, off_t offset); } | | 606 | int PAD, off_t offset); } |
607 | 290 STD RUMP { ssize_t|sys||pwritev(int fd, \ | | 607 | 290 STD RUMP { ssize_t|sys||pwritev(int fd, \ |
608 | const struct iovec *iovp, int iovcnt, \ | | 608 | const struct iovec *iovp, int iovcnt, \ |
609 | int PAD, off_t offset); } | | 609 | int PAD, off_t offset); } |
610 | 291 COMPAT_16 MODULAR compat_16 { int|sys|14|sigaction(int signum, \ | | 610 | 291 COMPAT_16 MODULAR compat_16 { int|sys|14|sigaction(int signum, \ |
611 | const struct sigaction *nsa, \ | | 611 | const struct sigaction *nsa, \ |
612 | struct sigaction *osa); } | | 612 | struct sigaction *osa); } |
613 | 292 STD { int|sys|14|sigpending(sigset_t *set); } | | 613 | 292 STD { int|sys|14|sigpending(sigset_t *set); } |
614 | 293 STD { int|sys|14|sigprocmask(int how, \ | | 614 | 293 STD { int|sys|14|sigprocmask(int how, \ |
615 | const sigset_t *set, \ | | 615 | const sigset_t *set, \ |
616 | sigset_t *oset); } | | 616 | sigset_t *oset); } |
617 | 294 STD { int|sys|14|sigsuspend(const sigset_t *set); } | | 617 | 294 STD { int|sys|14|sigsuspend(const sigset_t *set); } |
618 | 295 COMPAT_16 MODULAR compat_16 \ | | 618 | 295 COMPAT_16 MODULAR compat_16 \ |
619 | { int|sys|14|sigreturn(struct sigcontext *sigcntxp); } | | 619 | { int|sys|14|sigreturn(struct sigcontext *sigcntxp); } |
620 | 296 STD RUMP { int|sys||__getcwd(char *bufp, size_t length); } | | 620 | 296 STD RUMP { int|sys||__getcwd(char *bufp, size_t length); } |
621 | 297 STD RUMP { int|sys||fchroot(int fd); } | | 621 | 297 STD RUMP { int|sys||fchroot(int fd); } |
622 | 298 COMPAT_30 MODULAR compat_30 \ | | 622 | 298 COMPAT_30 MODULAR compat_30 \ |
623 | { int|sys||fhopen(const struct compat_30_fhandle *fhp, int flags); } | | 623 | { int|sys||fhopen(const struct compat_30_fhandle *fhp, int flags); } |
624 | 299 COMPAT_30 MODULAR compat_30 \ | | 624 | 299 COMPAT_30 MODULAR compat_30 \ |
625 | { int|sys||fhstat(const struct compat_30_fhandle *fhp, \ | | 625 | { int|sys||fhstat(const struct compat_30_fhandle *fhp, \ |
626 | struct stat13 *sb); } | | 626 | struct stat13 *sb); } |
627 | 300 COMPAT_20 MODULAR compat_20 \ | | 627 | 300 COMPAT_20 MODULAR compat_20 \ |
628 | { int|sys||fhstatfs(const struct compat_30_fhandle *fhp, \ | | 628 | { int|sys||fhstatfs(const struct compat_30_fhandle *fhp, \ |
629 | struct statfs12 *buf); } | | 629 | struct statfs12 *buf); } |
630 | 301 COMPAT_50 MODULAR compat_sysv_50 \ | | 630 | 301 COMPAT_50 MODULAR compat_sysv_50 \ |
631 | { int|sys|13|__semctl(int semid, int semnum, int cmd, \ | | 631 | { int|sys|13|__semctl(int semid, int semnum, int cmd, \ |
632 | ... union __semun *arg); } | | 632 | ... union __semun *arg); } |
633 | 302 COMPAT_50 MODULAR compat_sysv_50 \ | | 633 | 302 COMPAT_50 MODULAR compat_sysv_50 \ |
634 | { int|sys|13|msgctl(int msqid, int cmd, struct msqid_ds *buf); } | | 634 | { int|sys|13|msgctl(int msqid, int cmd, struct msqid_ds *buf); } |
635 | 303 COMPAT_50 MODULAR compat_sysv_50 \ | | 635 | 303 COMPAT_50 MODULAR compat_sysv_50 \ |
636 | { int|sys|13|shmctl(int shmid, int cmd, \ | | 636 | { int|sys|13|shmctl(int shmid, int cmd, \ |
637 | struct shmid_ds13 *buf); } | | 637 | struct shmid_ds13 *buf); } |
638 | 304 STD RUMP { int|sys||lchflags(const char *path, u_long flags); } | | 638 | 304 STD RUMP { int|sys||lchflags(const char *path, u_long flags); } |
639 | 305 NOERR RUMP { int|sys||issetugid(void); } | | 639 | 305 NOERR RUMP { int|sys||issetugid(void); } |
640 | 306 STD RUMP { int|sys||utrace(const char *label, void *addr, \ | | 640 | 306 STD RUMP { int|sys||utrace(const char *label, void *addr, \ |
641 | size_t len); } | | 641 | size_t len); } |
642 | 307 STD { int|sys||getcontext(struct __ucontext *ucp); } | | 642 | 307 STD { int|sys||getcontext(struct __ucontext *ucp); } |
643 | 308 STD { int|sys||setcontext(const struct __ucontext *ucp); } | | 643 | 308 STD { int|sys||setcontext(const struct __ucontext *ucp); } |
644 | 309 STD { int|sys||_lwp_create(const struct __ucontext *ucp, \ | | 644 | 309 STD { int|sys||_lwp_create(const struct __ucontext *ucp, \ |
645 | u_long flags, lwpid_t *new_lwp); } | | 645 | u_long flags, lwpid_t *new_lwp); } |
646 | 310 STD { int|sys||_lwp_exit(void); } | | 646 | 310 STD { int|sys||_lwp_exit(void); } |
647 | 311 STD { lwpid_t|sys||_lwp_self(void); } | | 647 | 311 STD { lwpid_t|sys||_lwp_self(void); } |
648 | 312 STD { int|sys||_lwp_wait(lwpid_t wait_for, \ | | 648 | 312 STD { int|sys||_lwp_wait(lwpid_t wait_for, \ |
649 | lwpid_t *departed); } | | 649 | lwpid_t *departed); } |
650 | 313 STD { int|sys||_lwp_suspend(lwpid_t target); } | | 650 | 313 STD { int|sys||_lwp_suspend(lwpid_t target); } |
651 | 314 STD { int|sys||_lwp_continue(lwpid_t target); } | | 651 | 314 STD { int|sys||_lwp_continue(lwpid_t target); } |
652 | 315 STD { int|sys||_lwp_wakeup(lwpid_t target); } | | 652 | 315 STD { int|sys||_lwp_wakeup(lwpid_t target); } |
653 | 316 STD { void *|sys||_lwp_getprivate(void); } | | 653 | 316 STD { void *|sys||_lwp_getprivate(void); } |
654 | 317 STD { void|sys||_lwp_setprivate(void *ptr); } | | 654 | 317 STD { void|sys||_lwp_setprivate(void *ptr); } |
655 | 318 STD { int|sys||_lwp_kill(lwpid_t target, int signo); } | | 655 | 318 STD { int|sys||_lwp_kill(lwpid_t target, int signo); } |
656 | 319 STD { int|sys||_lwp_detach(lwpid_t target); } | | 656 | 319 STD { int|sys||_lwp_detach(lwpid_t target); } |
657 | 320 COMPAT_50 MODULAR compat_50 \ | | 657 | 320 COMPAT_50 MODULAR compat_50 \ |
658 | { int|sys||_lwp_park(const struct timespec50 *ts, \ | | 658 | { int|sys||_lwp_park(const struct timespec50 *ts, \ |
659 | lwpid_t unpark, const void *hint, \ | | 659 | lwpid_t unpark, const void *hint, \ |
660 | const void *unparkhint); } | | 660 | const void *unparkhint); } |
661 | 321 STD { int|sys||_lwp_unpark(lwpid_t target, const void *hint); } | | 661 | 321 STD { int|sys||_lwp_unpark(lwpid_t target, const void *hint); } |
662 | 322 STD { ssize_t|sys||_lwp_unpark_all(const lwpid_t *targets, \ | | 662 | 322 STD { ssize_t|sys||_lwp_unpark_all(const lwpid_t *targets, \ |
663 | size_t ntargets, const void *hint); } | | 663 | size_t ntargets, const void *hint); } |
664 | 323 STD { int|sys||_lwp_setname(lwpid_t target, \ | | 664 | 323 STD { int|sys||_lwp_setname(lwpid_t target, \ |
665 | const char *name); } | | 665 | const char *name); } |
666 | 324 STD { int|sys||_lwp_getname(lwpid_t target, \ | | 666 | 324 STD { int|sys||_lwp_getname(lwpid_t target, \ |
667 | char *name, size_t len); } | | 667 | char *name, size_t len); } |
668 | 325 STD { int|sys||_lwp_ctl(int features, \ | | 668 | 325 STD { int|sys||_lwp_ctl(int features, \ |
669 | struct lwpctl **address); } | | 669 | struct lwpctl **address); } |
670 | ; Syscalls 326-339 reserved for LWP syscalls. | | 670 | ; Syscalls 326-339 reserved for LWP syscalls. |
671 | 326 UNIMPL | | 671 | 326 UNIMPL |
672 | 327 UNIMPL | | 672 | 327 UNIMPL |
673 | 328 UNIMPL | | 673 | 328 UNIMPL |
674 | 329 UNIMPL | | 674 | 329 UNIMPL |
675 | ; SA system calls. | | 675 | ; SA system calls. |
676 | 330 COMPAT_60 MODULAR compat_60 \ | | 676 | 330 COMPAT_60 MODULAR compat_60 \ |
677 | { int|sys||sa_register(void *newv, void **oldv, \ | | 677 | { int|sys||sa_register(void *newv, void **oldv, \ |
678 | int flags, ssize_t stackinfo_offset); } | | 678 | int flags, ssize_t stackinfo_offset); } |
679 | 331 COMPAT_60 MODULAR compat_60 \ | | 679 | 331 COMPAT_60 MODULAR compat_60 \ |
680 | { int|sys||sa_stacks(int num, stack_t *stacks); } | | 680 | { int|sys||sa_stacks(int num, stack_t *stacks); } |
681 | 332 COMPAT_60 MODULAR compat_60 \ | | 681 | 332 COMPAT_60 MODULAR compat_60 \ |
682 | { int|sys||sa_enable(void); } | | 682 | { int|sys||sa_enable(void); } |
683 | 333 COMPAT_60 MODULAR compat_60 \ | | 683 | 333 COMPAT_60 MODULAR compat_60 \ |
684 | { int|sys||sa_setconcurrency(int concurrency); } | | 684 | { int|sys||sa_setconcurrency(int concurrency); } |
685 | 334 COMPAT_60 MODULAR compat_60 \ | | 685 | 334 COMPAT_60 MODULAR compat_60 \ |
686 | { int|sys||sa_yield(void); } | | 686 | { int|sys||sa_yield(void); } |
687 | 335 COMPAT_60 MODULAR compat_60 \ | | 687 | 335 COMPAT_60 MODULAR compat_60 \ |
688 | { int|sys||sa_preempt(int sa_id); } | | 688 | { int|sys||sa_preempt(int sa_id); } |
689 | 336 OBSOL sys_sa_unblockyield | | 689 | 336 OBSOL sys_sa_unblockyield |
690 | ; | | 690 | ; |
691 | ; Syscalls 337-339 are reserved for other scheduler activation syscalls. | | 691 | ; Syscalls 337-339 are reserved for other scheduler activation syscalls. |
692 | ; | | 692 | ; |
693 | 337 UNIMPL | | 693 | 337 UNIMPL |
694 | 338 UNIMPL | | 694 | 338 UNIMPL |
695 | 339 UNIMPL | | 695 | 339 UNIMPL |
696 | 340 STD { int|sys||__sigaction_sigtramp(int signum, \ | | 696 | 340 STD { int|sys||__sigaction_sigtramp(int signum, \ |
697 | const struct sigaction *nsa, \ | | 697 | const struct sigaction *nsa, \ |
698 | struct sigaction *osa, \ | | 698 | struct sigaction *osa, \ |
699 | const void *tramp, int vers); } | | 699 | const void *tramp, int vers); } |
700 | 341 OBSOL sys_pmc_get_info | | 700 | 341 OBSOL sys_pmc_get_info |
701 | 342 OBSOL sys_pmc_control | | 701 | 342 OBSOL sys_pmc_control |
702 | 343 STD { int|sys||rasctl(void *addr, size_t len, int op); } | | 702 | 343 STD { int|sys||rasctl(void *addr, size_t len, int op); } |
703 | 344 STD RUMP { int|sys||kqueue(void); } | | 703 | 344 STD RUMP { int|sys||kqueue(void); } |
704 | 345 COMPAT_50 MODULAR compat_50 RUMP { int|sys||kevent(int fd, \ | | 704 | 345 COMPAT_50 MODULAR compat_50 RUMP { int|sys||kevent(int fd, \ |
705 | const struct kevent *changelist, size_t nchanges, \ | | 705 | const struct kevent *changelist, size_t nchanges, \ |
706 | struct kevent *eventlist, size_t nevents, \ | | 706 | struct kevent *eventlist, size_t nevents, \ |
707 | const struct timespec50 *timeout); } | | 707 | const struct timespec50 *timeout); } |
708 | | | 708 | |
709 | ; Scheduling system calls. | | 709 | ; Scheduling system calls. |
710 | 346 STD { int|sys||_sched_setparam(pid_t pid, lwpid_t lid, \ | | 710 | 346 STD { int|sys||_sched_setparam(pid_t pid, lwpid_t lid, \ |
711 | int policy, const struct sched_param *params); } | | 711 | int policy, const struct sched_param *params); } |
712 | 347 STD { int|sys||_sched_getparam(pid_t pid, lwpid_t lid, \ | | 712 | 347 STD { int|sys||_sched_getparam(pid_t pid, lwpid_t lid, \ |
713 | int *policy, struct sched_param *params); } | | 713 | int *policy, struct sched_param *params); } |
714 | 348 STD { int|sys||_sched_setaffinity(pid_t pid, lwpid_t lid, \ | | 714 | 348 STD { int|sys||_sched_setaffinity(pid_t pid, lwpid_t lid, \ |
715 | size_t size, const cpuset_t *cpuset); } | | 715 | size_t size, const cpuset_t *cpuset); } |
716 | 349 STD { int|sys||_sched_getaffinity(pid_t pid, lwpid_t lid, \ | | 716 | 349 STD { int|sys||_sched_getaffinity(pid_t pid, lwpid_t lid, \ |
717 | size_t size, cpuset_t *cpuset); } | | 717 | size_t size, cpuset_t *cpuset); } |
718 | 350 STD { int|sys||sched_yield(void); } | | 718 | 350 STD { int|sys||sched_yield(void); } |
719 | 351 STD { int|sys||_sched_protect(int priority); } | | 719 | 351 STD { int|sys||_sched_protect(int priority); } |
720 | 352 UNIMPL | | 720 | 352 UNIMPL |
721 | 353 UNIMPL | | 721 | 353 UNIMPL |
722 | | | 722 | |
723 | 354 STD RUMP { int|sys||fsync_range(int fd, int flags, off_t start, \ | | 723 | 354 STD RUMP { int|sys||fsync_range(int fd, int flags, off_t start, \ |
724 | off_t length); } | | 724 | off_t length); } |
725 | 355 STD { int|sys||uuidgen(struct uuid *store, int count); } | | 725 | 355 STD { int|sys||uuidgen(struct uuid *store, int count); } |
726 | 356 COMPAT_90 MODULAR compat_90 { \ | | 726 | 356 COMPAT_90 MODULAR compat_90 { \ |
727 | int|sys||getvfsstat(struct statvfs90 *buf, \ | | 727 | int|sys||getvfsstat(struct statvfs90 *buf, \ |
728 | size_t bufsize, int flags); } | | 728 | size_t bufsize, int flags); } |
729 | 357 COMPAT_90 MODULAR compat_90 { int|sys||statvfs1(const char *path, \ | | 729 | 357 COMPAT_90 MODULAR compat_90 { int|sys||statvfs1(const char *path, \ |
730 | struct statvfs90 *buf, int flags); } | | 730 | struct statvfs90 *buf, int flags); } |
731 | 358 COMPAT_90 MODULAR compat_90 { int|sys||fstatvfs1(int fd, \ | | 731 | 358 COMPAT_90 MODULAR compat_90 { int|sys||fstatvfs1(int fd, \ |
732 | struct statvfs90 *buf, int flags); } | | 732 | struct statvfs90 *buf, int flags); } |
733 | 359 COMPAT_30 MODULAR compat_30 { int|sys||fhstatvfs1( \ | | 733 | 359 COMPAT_30 MODULAR compat_30 { int|sys||fhstatvfs1( \ |
734 | const struct compat_30_fhandle *fhp, \ | | 734 | const struct compat_30_fhandle *fhp, \ |
735 | struct statvfs90 *buf, int flags); } | | 735 | struct statvfs90 *buf, int flags); } |
736 | 360 STD RUMP { int|sys||extattrctl(const char *path, int cmd, \ | | 736 | 360 STD RUMP { int|sys||extattrctl(const char *path, int cmd, \ |
737 | const char *filename, int attrnamespace, \ | | 737 | const char *filename, int attrnamespace, \ |
738 | const char *attrname); } | | 738 | const char *attrname); } |
739 | 361 STD RUMP { int|sys||extattr_set_file(const char *path, \ | | 739 | 361 STD RUMP { int|sys||extattr_set_file(const char *path, \ |
740 | int attrnamespace, const char *attrname, \ | | 740 | int attrnamespace, const char *attrname, \ |
741 | const void *data, size_t nbytes); } | | 741 | const void *data, size_t nbytes); } |
742 | 362 STD RUMP { ssize_t|sys||extattr_get_file(const char *path, \ | | 742 | 362 STD RUMP { ssize_t|sys||extattr_get_file(const char *path, \ |
743 | int attrnamespace, const char *attrname, \ | | 743 | int attrnamespace, const char *attrname, \ |
744 | void *data, size_t nbytes); } | | 744 | void *data, size_t nbytes); } |
745 | 363 STD RUMP { int|sys||extattr_delete_file(const char *path, \ | | 745 | 363 STD RUMP { int|sys||extattr_delete_file(const char *path, \ |
746 | int attrnamespace, const char *attrname); } | | 746 | int attrnamespace, const char *attrname); } |
747 | 364 STD RUMP { int|sys||extattr_set_fd(int fd, \ | | 747 | 364 STD RUMP { int|sys||extattr_set_fd(int fd, \ |
748 | int attrnamespace, const char *attrname, \ | | 748 | int attrnamespace, const char *attrname, \ |
749 | const void *data, size_t nbytes); } | | 749 | const void *data, size_t nbytes); } |
750 | 365 STD RUMP { ssize_t|sys||extattr_get_fd(int fd, \ | | 750 | 365 STD RUMP { ssize_t|sys||extattr_get_fd(int fd, \ |
751 | int attrnamespace, const char *attrname, \ | | 751 | int attrnamespace, const char *attrname, \ |
752 | void *data, size_t nbytes); } | | 752 | void *data, size_t nbytes); } |
753 | 366 STD RUMP { int|sys||extattr_delete_fd(int fd, \ | | 753 | 366 STD RUMP { int|sys||extattr_delete_fd(int fd, \ |
754 | int attrnamespace, const char *attrname); } | | 754 | int attrnamespace, const char *attrname); } |
755 | 367 STD RUMP { int|sys||extattr_set_link(const char *path, \ | | 755 | 367 STD RUMP { int|sys||extattr_set_link(const char *path, \ |
756 | int attrnamespace, const char *attrname, \ | | 756 | int attrnamespace, const char *attrname, \ |
757 | const void *data, size_t nbytes); } | | 757 | const void *data, size_t nbytes); } |
758 | 368 STD RUMP { ssize_t|sys||extattr_get_link(const char *path, \ | | 758 | 368 STD RUMP { ssize_t|sys||extattr_get_link(const char *path, \ |
759 | int attrnamespace, const char *attrname, \ | | 759 | int attrnamespace, const char *attrname, \ |
760 | void *data, size_t nbytes); } | | 760 | void *data, size_t nbytes); } |
761 | 369 STD RUMP { int|sys||extattr_delete_link(const char *path, \ | | 761 | 369 STD RUMP { int|sys||extattr_delete_link(const char *path, \ |
762 | int attrnamespace, const char *attrname); } | | 762 | int attrnamespace, const char *attrname); } |
763 | 370 STD RUMP { ssize_t|sys||extattr_list_fd(int fd, \ | | 763 | 370 STD RUMP { ssize_t|sys||extattr_list_fd(int fd, \ |
764 | int attrnamespace, void *data, size_t nbytes); } | | 764 | int attrnamespace, void *data, size_t nbytes); } |
765 | 371 STD RUMP { ssize_t|sys||extattr_list_file(const char *path, \ | | 765 | 371 STD RUMP { ssize_t|sys||extattr_list_file(const char *path, \ |
766 | int attrnamespace, void *data, size_t nbytes); } | | 766 | int attrnamespace, void *data, size_t nbytes); } |
767 | 372 STD RUMP { ssize_t|sys||extattr_list_link(const char *path, \ | | 767 | 372 STD RUMP { ssize_t|sys||extattr_list_link(const char *path, \ |
768 | int attrnamespace, void *data, size_t nbytes); } | | 768 | int attrnamespace, void *data, size_t nbytes); } |
769 | 373 COMPAT_50 MODULAR compat_50 RUMP \ | | 769 | 373 COMPAT_50 MODULAR compat_50 RUMP \ |
770 | { int|sys||pselect(int nd, fd_set *in, fd_set *ou, \ | | 770 | { int|sys||pselect(int nd, fd_set *in, fd_set *ou, \ |
771 | fd_set *ex, const struct timespec50 *ts, \ | | 771 | fd_set *ex, const struct timespec50 *ts, \ |
772 | const sigset_t *mask); } | | 772 | const sigset_t *mask); } |
773 | 374 COMPAT_50 MODULAR compat_50 RUMP \ | | 773 | 374 COMPAT_50 MODULAR compat_50 RUMP \ |
774 | { int|sys||pollts(struct pollfd *fds, u_int nfds, \ | | 774 | { int|sys||pollts(struct pollfd *fds, u_int nfds, \ |
775 | const struct timespec50 *ts, const sigset_t *mask); } | | 775 | const struct timespec50 *ts, const sigset_t *mask); } |
776 | 375 STD RUMP { int|sys||setxattr(const char *path, \ | | 776 | 375 STD RUMP { int|sys||setxattr(const char *path, \ |
777 | const char *name, const void *value, size_t size, \ | | 777 | const char *name, const void *value, size_t size, \ |
778 | int flags); } | | 778 | int flags); } |
779 | 376 STD RUMP { int|sys||lsetxattr(const char *path, \ | | 779 | 376 STD RUMP { int|sys||lsetxattr(const char *path, \ |
780 | const char *name, const void *value, size_t size, \ | | 780 | const char *name, const void *value, size_t size, \ |
781 | int flags); } | | 781 | int flags); } |
782 | 377 STD RUMP { int|sys||fsetxattr(int fd, \ | | 782 | 377 STD RUMP { int|sys||fsetxattr(int fd, \ |
783 | const char *name, const void *value, size_t size, \ | | 783 | const char *name, const void *value, size_t size, \ |
784 | int flags); } | | 784 | int flags); } |
785 | 378 STD RUMP { int|sys||getxattr(const char *path, \ | | 785 | 378 STD RUMP { int|sys||getxattr(const char *path, \ |
786 | const char *name, void *value, size_t size); } | | 786 | const char *name, void *value, size_t size); } |
787 | 379 STD RUMP { int|sys||lgetxattr(const char *path, \ | | 787 | 379 STD RUMP { int|sys||lgetxattr(const char *path, \ |
788 | const char *name, void *value, size_t size); } | | 788 | const char *name, void *value, size_t size); } |
789 | 380 STD RUMP { int|sys||fgetxattr(int fd, \ | | 789 | 380 STD RUMP { int|sys||fgetxattr(int fd, \ |
790 | const char *name, void *value, size_t size); } | | 790 | const char *name, void *value, size_t size); } |
791 | 381 STD RUMP { int|sys||listxattr(const char *path, \ | | 791 | 381 STD RUMP { int|sys||listxattr(const char *path, \ |
792 | char *list, size_t size); } | | 792 | char *list, size_t size); } |
793 | 382 STD RUMP { int|sys||llistxattr(const char *path, \ | | 793 | 382 STD RUMP { int|sys||llistxattr(const char *path, \ |
794 | char *list, size_t size); } | | 794 | char *list, size_t size); } |
795 | 383 STD RUMP { int|sys||flistxattr(int fd, \ | | 795 | 383 STD RUMP { int|sys||flistxattr(int fd, \ |
796 | char *list, size_t size); } | | 796 | char *list, size_t size); } |
797 | 384 STD RUMP { int|sys||removexattr(const char *path, \ | | 797 | 384 STD RUMP { int|sys||removexattr(const char *path, \ |
798 | const char *name); } | | 798 | const char *name); } |
799 | 385 STD RUMP { int|sys||lremovexattr(const char *path, \ | | 799 | 385 STD RUMP { int|sys||lremovexattr(const char *path, \ |
800 | const char *name); } | | 800 | const char *name); } |
801 | 386 STD RUMP { int|sys||fremovexattr(int fd, \ | | 801 | 386 STD RUMP { int|sys||fremovexattr(int fd, \ |
802 | const char *name); } | | 802 | const char *name); } |
803 | 387 COMPAT_50 MODULAR compat_50 RUMP \ | | 803 | 387 COMPAT_50 MODULAR compat_50 RUMP \ |
804 | { int|sys|30|stat(const char *path, struct stat30 *ub); } | | 804 | { int|sys|30|stat(const char *path, struct stat30 *ub); } |
805 | 388 COMPAT_50 MODULAR compat_50 RUMP \ | | 805 | 388 COMPAT_50 MODULAR compat_50 RUMP \ |
806 | { int|sys|30|fstat(int fd, struct stat30 *sb); } | | 806 | { int|sys|30|fstat(int fd, struct stat30 *sb); } |
807 | 389 COMPAT_50 MODULAR compat_50 RUMP \ | | 807 | 389 COMPAT_50 MODULAR compat_50 RUMP \ |
808 | { int|sys|30|lstat(const char *path, struct stat30 *ub); } | | 808 | { int|sys|30|lstat(const char *path, struct stat30 *ub); } |
809 | 390 STD RUMP { int|sys|30|getdents(int fd, char *buf, size_t count); } | | 809 | 390 STD RUMP { int|sys|30|getdents(int fd, char *buf, size_t count); } |
810 | 391 IGNORED old posix_fadvise | | 810 | 391 IGNORED old posix_fadvise |
811 | 392 COMPAT_30 MODULAR compat_30 \ | | 811 | 392 COMPAT_30 MODULAR compat_30 \ |
812 | { int|sys|30|fhstat(const struct compat_30_fhandle \ | | 812 | { int|sys|30|fhstat(const struct compat_30_fhandle \ |
813 | *fhp, struct stat30 *sb); } | | 813 | *fhp, struct stat30 *sb); } |
814 | 393 COMPAT_50 MODULAR compat_30 \ | | 814 | 393 COMPAT_50 MODULAR compat_30 \ |
815 | { int|sys|30|ntp_gettime(struct ntptimeval50 *ntvp); } | | 815 | { int|sys|30|ntp_gettime(struct ntptimeval50 *ntvp); } |
816 | 394 STD RUMP { int|sys|30|socket(int domain, int type, int protocol); } | | 816 | 394 STD RUMP { int|sys|30|socket(int domain, int type, int protocol); } |
817 | 395 STD RUMP { int|sys|30|getfh(const char *fname, void *fhp, \ | | 817 | 395 STD RUMP { int|sys|30|getfh(const char *fname, void *fhp, \ |
818 | size_t *fh_size); } | | 818 | size_t *fh_size); } |
819 | 396 STD RUMP { int|sys|40|fhopen(const void *fhp, size_t fh_size,\ | | 819 | 396 STD RUMP { int|sys|40|fhopen(const void *fhp, size_t fh_size,\ |
820 | int flags); } | | 820 | int flags); } |
821 | 397 COMPAT_90 MODULAR compat_90 { \ | | 821 | 397 COMPAT_90 MODULAR compat_90 { \ |
822 | int|sys||fhstatvfs1(const void *fhp, \ | | 822 | int|sys||fhstatvfs1(const void *fhp, \ |
823 | size_t fh_size, struct statvfs90 *buf, int flags); } | | 823 | size_t fh_size, struct statvfs90 *buf, int flags); } |
824 | 398 COMPAT_50 MODULAR compat_50 RUMP { int|sys|40|fhstat(const void *fhp, \ | | 824 | 398 COMPAT_50 MODULAR compat_50 RUMP { int|sys|40|fhstat(const void *fhp, \ |
825 | size_t fh_size, struct stat30 *sb); } | | 825 | size_t fh_size, struct stat30 *sb); } |
826 | | | 826 | |
827 | ; Asynchronous I/O system calls | | 827 | ; Asynchronous I/O system calls |
828 | 399 STD MODULAR aio RUMP \ | | 828 | 399 STD MODULAR aio RUMP \ |
829 | { int|sys||aio_cancel(int fildes, struct aiocb *aiocbp); } | | 829 | { int|sys||aio_cancel(int fildes, struct aiocb *aiocbp); } |
830 | 400 STD MODULAR aio RUMP \ | | 830 | 400 STD MODULAR aio RUMP \ |
831 | { int|sys||aio_error(const struct aiocb *aiocbp); } | | 831 | { int|sys||aio_error(const struct aiocb *aiocbp); } |
832 | 401 STD MODULAR aio RUMP \ | | 832 | 401 STD MODULAR aio RUMP \ |
833 | { int|sys||aio_fsync(int op, struct aiocb *aiocbp); } | | 833 | { int|sys||aio_fsync(int op, struct aiocb *aiocbp); } |
834 | 402 STD MODULAR aio RUMP \ | | 834 | 402 STD MODULAR aio RUMP \ |
835 | { int|sys||aio_read(struct aiocb *aiocbp); } | | 835 | { int|sys||aio_read(struct aiocb *aiocbp); } |
836 | 403 STD MODULAR aio RUMP \ | | 836 | 403 STD MODULAR aio RUMP \ |
837 | { int|sys||aio_return(struct aiocb *aiocbp); } | | 837 | { int|sys||aio_return(struct aiocb *aiocbp); } |
838 | 404 COMPAT_50 MODULAR compat \ | | 838 | 404 COMPAT_50 MODULAR compat \ |
839 | { int|sys||aio_suspend(const struct aiocb *const *list, \ | | 839 | { int|sys||aio_suspend(const struct aiocb *const *list, \ |
840 | int nent, const struct timespec50 *timeout); } | | 840 | int nent, const struct timespec50 *timeout); } |
841 | 405 STD MODULAR aio RUMP \ | | 841 | 405 STD MODULAR aio RUMP \ |
842 | { int|sys||aio_write(struct aiocb *aiocbp); } | | 842 | { int|sys||aio_write(struct aiocb *aiocbp); } |
843 | 406 STD MODULAR aio RUMP \ | | 843 | 406 STD MODULAR aio RUMP \ |
844 | { int|sys||lio_listio(int mode, struct aiocb *const *list, \ | | 844 | { int|sys||lio_listio(int mode, struct aiocb *const *list, \ |
845 | int nent, struct sigevent *sig); } | | 845 | int nent, struct sigevent *sig); } |
846 | | | 846 | |
847 | 407 UNIMPL | | 847 | 407 UNIMPL |
848 | 408 UNIMPL | | 848 | 408 UNIMPL |
849 | 409 UNIMPL | | 849 | 409 UNIMPL |
850 | | | 850 | |
851 | 410 STD RUMP { int|sys|50|mount(const char *type, \ | | 851 | 410 STD RUMP { int|sys|50|mount(const char *type, \ |
852 | const char *path, int flags, void *data, \ | | 852 | const char *path, int flags, void *data, \ |
853 | size_t data_len); } | | 853 | size_t data_len); } |
854 | 411 STD { void *|sys||mremap(void *old_address, \ | | 854 | 411 STD { void *|sys||mremap(void *old_address, \ |
855 | size_t old_size, void *new_address, \ | | 855 | size_t old_size, void *new_address, \ |
856 | size_t new_size, int flags); } | | 856 | size_t new_size, int flags); } |
857 | | | 857 | |
858 | ; Processor-sets system calls | | 858 | ; Processor-sets system calls |
859 | 412 STD { int|sys||pset_create(psetid_t *psid); } | | 859 | 412 STD { int|sys||pset_create(psetid_t *psid); } |
860 | 413 STD { int|sys||pset_destroy(psetid_t psid); } | | 860 | 413 STD { int|sys||pset_destroy(psetid_t psid); } |
861 | 414 STD { int|sys||pset_assign(psetid_t psid, cpuid_t cpuid, \ | | 861 | 414 STD { int|sys||pset_assign(psetid_t psid, cpuid_t cpuid, \ |
862 | psetid_t *opsid); } | | 862 | psetid_t *opsid); } |
863 | 415 STD { int|sys||_pset_bind(idtype_t idtype, id_t first_id, \ | | 863 | 415 STD { int|sys||_pset_bind(idtype_t idtype, id_t first_id, \ |
864 | id_t second_id, psetid_t psid, psetid_t *opsid); } | | 864 | id_t second_id, psetid_t psid, psetid_t *opsid); } |
865 | 416 NOERR RUMP { int|sys|50|posix_fadvise(int fd, int PAD, \ | | 865 | 416 NOERR RUMP { int|sys|50|posix_fadvise(int fd, int PAD, \ |
866 | off_t offset, off_t len, int advice); } | | 866 | off_t offset, off_t len, int advice); } |
867 | 417 STD RUMP { int|sys|50|select(int nd, fd_set *in, fd_set *ou, \ | | 867 | 417 STD RUMP { int|sys|50|select(int nd, fd_set *in, fd_set *ou, \ |
868 | fd_set *ex, struct timeval *tv); } | | 868 | fd_set *ex, struct timeval *tv); } |
869 | 418 STD RUMP { int|sys|50|gettimeofday(struct timeval *tp, \ | | 869 | 418 STD RUMP { int|sys|50|gettimeofday(struct timeval *tp, \ |
870 | void *tzp); } | | 870 | void *tzp); } |
871 | 419 STD RUMP { int|sys|50|settimeofday(const struct timeval *tv, \ | | 871 | 419 STD RUMP { int|sys|50|settimeofday(const struct timeval *tv, \ |
872 | const void *tzp); } | | 872 | const void *tzp); } |
873 | 420 STD RUMP { int|sys|50|utimes(const char *path, \ | | 873 | 420 STD RUMP { int|sys|50|utimes(const char *path, \ |
874 | const struct timeval *tptr); } | | 874 | const struct timeval *tptr); } |
875 | 421 STD RUMP { int|sys|50|adjtime(const struct timeval *delta, \ | | 875 | 421 STD RUMP { int|sys|50|adjtime(const struct timeval *delta, \ |
876 | struct timeval *olddelta); } | | 876 | struct timeval *olddelta); } |
877 | 422 STD MODULAR lfs { int|sys|50|lfs_segwait(fsid_t *fsidp, \ | | 877 | 422 STD MODULAR lfs { int|sys|50|lfs_segwait(fsid_t *fsidp, \ |
878 | struct timeval *tv); } | | 878 | struct timeval *tv); } |
879 | 423 STD RUMP { int|sys|50|futimes(int fd, \ | | 879 | 423 STD RUMP { int|sys|50|futimes(int fd, \ |
880 | const struct timeval *tptr); } | | 880 | const struct timeval *tptr); } |
881 | 424 STD RUMP { int|sys|50|lutimes(const char *path, \ | | 881 | 424 STD RUMP { int|sys|50|lutimes(const char *path, \ |
882 | const struct timeval *tptr); } | | 882 | const struct timeval *tptr); } |
883 | 425 STD RUMP { int|sys|50|setitimer(int which, \ | | 883 | 425 STD RUMP { int|sys|50|setitimer(int which, \ |
884 | const struct itimerval *itv, \ | | 884 | const struct itimerval *itv, \ |
885 | struct itimerval *oitv); } | | 885 | struct itimerval *oitv); } |
886 | 426 STD RUMP { int|sys|50|getitimer(int which, \ | | 886 | 426 STD RUMP { int|sys|50|getitimer(int which, \ |
887 | struct itimerval *itv); } | | 887 | struct itimerval *itv); } |
888 | 427 STD RUMP { int|sys|50|clock_gettime(clockid_t clock_id, \ | | 888 | 427 STD RUMP { int|sys|50|clock_gettime(clockid_t clock_id, \ |
889 | struct timespec *tp); } | | 889 | struct timespec *tp); } |
890 | 428 STD RUMP { int|sys|50|clock_settime(clockid_t clock_id, \ | | 890 | 428 STD RUMP { int|sys|50|clock_settime(clockid_t clock_id, \ |
891 | const struct timespec *tp); } | | 891 | const struct timespec *tp); } |
892 | 429 STD RUMP { int|sys|50|clock_getres(clockid_t clock_id, \ | | 892 | 429 STD RUMP { int|sys|50|clock_getres(clockid_t clock_id, \ |
893 | struct timespec *tp); } | | 893 | struct timespec *tp); } |
894 | 430 STD RUMP { int|sys|50|nanosleep(const struct timespec *rqtp, \ | | 894 | 430 STD RUMP { int|sys|50|nanosleep(const struct timespec *rqtp, \ |
895 | struct timespec *rmtp); } | | 895 | struct timespec *rmtp); } |
896 | 431 STD { int|sys|50|__sigtimedwait(const sigset_t *set, \ | | 896 | 431 STD { int|sys|50|__sigtimedwait(const sigset_t *set, \ |
897 | siginfo_t *info, \ | | 897 | siginfo_t *info, \ |
898 | struct timespec *timeout); } | | 898 | struct timespec *timeout); } |
899 | 432 STD MODULAR mqueue \ | | 899 | 432 STD MODULAR mqueue \ |
900 | { int|sys|50|mq_timedsend(mqd_t mqdes, \ | | 900 | { int|sys|50|mq_timedsend(mqd_t mqdes, \ |
901 | const char *msg_ptr, size_t msg_len, \ | | 901 | const char *msg_ptr, size_t msg_len, \ |
902 | unsigned msg_prio, \ | | 902 | unsigned msg_prio, \ |
903 | const struct timespec *abs_timeout); } | | 903 | const struct timespec *abs_timeout); } |
904 | 433 STD MODULAR mqueue \ | | 904 | 433 STD MODULAR mqueue \ |
905 | { ssize_t|sys|50|mq_timedreceive(mqd_t mqdes, \ | | 905 | { ssize_t|sys|50|mq_timedreceive(mqd_t mqdes, \ |
906 | char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ | | 906 | char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ |
907 | const struct timespec *abs_timeout); } | | 907 | const struct timespec *abs_timeout); } |
908 | 434 COMPAT_60 MODULAR compat_60 \ | | 908 | 434 COMPAT_60 MODULAR compat_60 \ |
909 | { int|sys||_lwp_park(const struct timespec *ts, \ | | 909 | { int|sys||_lwp_park(const struct timespec *ts, \ |
910 | lwpid_t unpark, const void *hint, \ | | 910 | lwpid_t unpark, const void *hint, \ |
911 | const void *unparkhint); } | | 911 | const void *unparkhint); } |
912 | 435 STD RUMP { int|sys|50|kevent(int fd, \ | | 912 | 435 STD RUMP { int|sys|50|kevent(int fd, \ |
913 | const struct kevent *changelist, size_t nchanges, \ | | 913 | const struct kevent *changelist, size_t nchanges, \ |
914 | struct kevent *eventlist, size_t nevents, \ | | 914 | struct kevent *eventlist, size_t nevents, \ |
915 | const struct timespec *timeout); } | | 915 | const struct timespec *timeout); } |
916 | 436 STD RUMP { int|sys|50|pselect(int nd, fd_set *in, fd_set *ou, \ | | 916 | 436 STD RUMP { int|sys|50|pselect(int nd, fd_set *in, fd_set *ou, \ |
917 | fd_set *ex, const struct timespec *ts, \ | | 917 | fd_set *ex, const struct timespec *ts, \ |
918 | const sigset_t *mask); } | | 918 | const sigset_t *mask); } |
919 | 437 STD RUMP { int|sys|50|pollts(struct pollfd *fds, u_int nfds, \ | | 919 | 437 STD RUMP { int|sys|50|pollts(struct pollfd *fds, u_int nfds, \ |
920 | const struct timespec *ts, const sigset_t *mask); } | | 920 | const struct timespec *ts, const sigset_t *mask); } |
921 | 438 STD MODULAR aio RUMP { int|sys|50|aio_suspend( \ | | 921 | 438 STD MODULAR aio RUMP { int|sys|50|aio_suspend( \ |
922 | const struct aiocb *const *list, \ | | 922 | const struct aiocb *const *list, \ |
923 | int nent, const struct timespec *timeout); } | | 923 | int nent, const struct timespec *timeout); } |
924 | 439 STD RUMP { int|sys|50|stat(const char *path, struct stat *ub); } | | 924 | 439 STD RUMP { int|sys|50|stat(const char *path, struct stat *ub); } |
925 | 440 STD RUMP { int|sys|50|fstat(int fd, struct stat *sb); } | | 925 | 440 STD RUMP { int|sys|50|fstat(int fd, struct stat *sb); } |
926 | 441 STD RUMP { int|sys|50|lstat(const char *path, struct stat *ub); } | | 926 | 441 STD RUMP { int|sys|50|lstat(const char *path, struct stat *ub); } |
927 | 442 STD MODULAR sysv_ipc { int|sys|50|__semctl(int semid, int semnum, \ | | 927 | 442 STD MODULAR sysv_ipc { int|sys|50|__semctl(int semid, int semnum, \ |
928 | int cmd, ... union __semun *arg); } | | 928 | int cmd, ... union __semun *arg); } |
929 | 443 STD MODULAR sysv_ipc { int|sys|50|shmctl(int shmid, int cmd, \ | | 929 | 443 STD MODULAR sysv_ipc { int|sys|50|shmctl(int shmid, int cmd, \ |
930 | struct shmid_ds *buf); } | | 930 | struct shmid_ds *buf); } |
931 | 444 STD MODULAR sysv_ipc { int|sys|50|msgctl(int msqid, int cmd, \ | | 931 | 444 STD MODULAR sysv_ipc { int|sys|50|msgctl(int msqid, int cmd, \ |
932 | struct msqid_ds *buf); } | | 932 | struct msqid_ds *buf); } |
933 | 445 STD { int|sys|50|getrusage(int who, struct rusage *rusage); } | | 933 | 445 STD { int|sys|50|getrusage(int who, struct rusage *rusage); } |
934 | 446 STD RUMP { int|sys|50|timer_settime(timer_t timerid, \ | | 934 | 446 STD RUMP { int|sys|50|timer_settime(timer_t timerid, \ |
935 | int flags, const struct itimerspec *value, \ | | 935 | int flags, const struct itimerspec *value, \ |
936 | struct itimerspec *ovalue); } | | 936 | struct itimerspec *ovalue); } |
937 | 447 STD RUMP { int|sys|50|timer_gettime(timer_t timerid, struct \ | | 937 | 447 STD RUMP { int|sys|50|timer_gettime(timer_t timerid, struct \ |
938 | itimerspec *value); } | | 938 | itimerspec *value); } |
939 | #if defined(NTP) || !defined(_KERNEL_OPT) | | 939 | #if defined(NTP) || !defined(_KERNEL_OPT) |
940 | 448 STD { int|sys|50|ntp_gettime(struct ntptimeval *ntvp); } | | 940 | 448 STD { int|sys|50|ntp_gettime(struct ntptimeval *ntvp); } |
941 | #else | | 941 | #else |
942 | 448 EXCL ___ntp_gettime50 | | 942 | 448 EXCL ___ntp_gettime50 |
943 | #endif | | 943 | #endif |
944 | 449 STD { int|sys|50|wait4(pid_t pid, int *status, \ | | 944 | 449 STD { int|sys|50|wait4(pid_t pid, int *status, \ |
945 | int options, struct rusage *rusage); } | | 945 | int options, struct rusage *rusage); } |
946 | 450 STD RUMP { int|sys|50|mknod(const char *path, mode_t mode, \ | | 946 | 450 STD RUMP { int|sys|50|mknod(const char *path, mode_t mode, \ |
947 | dev_t dev); } | | 947 | dev_t dev); } |
948 | 451 STD RUMP { int|sys|50|fhstat(const void *fhp, \ | | 948 | 451 STD RUMP { int|sys|50|fhstat(const void *fhp, \ |
949 | size_t fh_size, struct stat *sb); } | | 949 | size_t fh_size, struct stat *sb); } |
950 | ; 452 only ever appeared in 5.99.x and can be reused after netbsd-7 | | 950 | ; 452 only ever appeared in 5.99.x and can be reused after netbsd-7 |
951 | 452 OBSOL 5.99 quotactl | | 951 | 452 OBSOL 5.99 quotactl |
952 | 453 STD RUMP { int|sys||pipe2(int *fildes, int flags); } | | 952 | 453 STD RUMP { int|sys||pipe2(int *fildes, int flags); } |
953 | 454 STD RUMP { int|sys||dup3(int from, int to, int flags); } | | 953 | 454 STD RUMP { int|sys||dup3(int from, int to, int flags); } |
954 | 455 STD RUMP { int|sys||kqueue1(int flags); } | | 954 | 455 STD RUMP { int|sys||kqueue1(int flags); } |
955 | 456 STD RUMP { int|sys||paccept(int s, struct sockaddr *name, \ | | 955 | 456 STD RUMP { int|sys||paccept(int s, struct sockaddr *name, \ |
956 | socklen_t *anamelen, const sigset_t *mask, \ | | 956 | socklen_t *anamelen, const sigset_t *mask, \ |
957 | int flags); } | | 957 | int flags); } |
958 | 457 STD RUMP { int|sys||linkat(int fd1, const char *name1, \ | | 958 | 457 STD RUMP { int|sys||linkat(int fd1, const char *name1, \ |
959 | int fd2, const char *name2, int flags); } | | 959 | int fd2, const char *name2, int flags); } |
960 | 458 STD RUMP { int|sys||renameat(int fromfd, const char *from, \ | | 960 | 458 STD RUMP { int|sys||renameat(int fromfd, const char *from, \ |
961 | int tofd, const char *to); } | | 961 | int tofd, const char *to); } |
962 | 459 STD RUMP { int|sys||mkfifoat(int fd, const char *path, \ | | 962 | 459 STD RUMP { int|sys||mkfifoat(int fd, const char *path, \ |
963 | mode_t mode); } | | 963 | mode_t mode); } |
964 | 460 STD RUMP { int|sys||mknodat(int fd, const char *path, \ | | 964 | 460 STD RUMP { int|sys||mknodat(int fd, const char *path, \ |
965 | mode_t mode, int PAD, dev_t dev); } | | 965 | mode_t mode, int PAD, dev_t dev); } |
966 | 461 STD RUMP { int|sys||mkdirat(int fd, const char *path, \ | | 966 | 461 STD RUMP { int|sys||mkdirat(int fd, const char *path, \ |
967 | mode_t mode); } | | 967 | mode_t mode); } |
968 | 462 STD RUMP { int|sys||faccessat(int fd, const char *path, \ | | 968 | 462 STD RUMP { int|sys||faccessat(int fd, const char *path, \ |
969 | int amode, int flag); } | | 969 | int amode, int flag); } |
970 | 463 STD RUMP { int|sys||fchmodat(int fd, const char *path, \ | | 970 | 463 STD RUMP { int|sys||fchmodat(int fd, const char *path, \ |
971 | mode_t mode, int flag); } | | 971 | mode_t mode, int flag); } |
972 | 464 STD RUMP { int|sys||fchownat(int fd, const char *path, \ | | 972 | 464 STD RUMP { int|sys||fchownat(int fd, const char *path, \ |
973 | uid_t owner, gid_t group, int flag); } | | 973 | uid_t owner, gid_t group, int flag); } |
974 | 465 STD { int|sys||fexecve(int fd, \ | | 974 | 465 STD { int|sys||fexecve(int fd, \ |
975 | char * const *argp, char * const *envp); } | | 975 | char * const *argp, char * const *envp); } |
976 | 466 STD RUMP { int|sys||fstatat(int fd, const char *path, \ | | 976 | 466 STD RUMP { int|sys||fstatat(int fd, const char *path, \ |
977 | struct stat *buf, int flag); } | | 977 | struct stat *buf, int flag); } |
978 | 467 STD RUMP { int|sys||utimensat(int fd, const char *path, \ | | 978 | 467 STD RUMP { int|sys||utimensat(int fd, const char *path, \ |
979 | const struct timespec *tptr, int flag); } | | 979 | const struct timespec *tptr, int flag); } |
980 | 468 STD RUMP { int|sys||openat(int fd, const char *path, \ | | 980 | 468 STD RUMP { int|sys||openat(int fd, const char *path, \ |
981 | int oflags, ... mode_t mode); } | | 981 | int oflags, ... mode_t mode); } |
982 | 469 STD RUMP { ssize_t|sys||readlinkat(int fd, const char *path, \ | | 982 | 469 STD RUMP { ssize_t|sys||readlinkat(int fd, const char *path, \ |
983 | char *buf, size_t bufsize); } | | 983 | char *buf, size_t bufsize); } |
984 | 470 STD RUMP { int|sys||symlinkat(const char *path1, int fd, \ | | 984 | 470 STD RUMP { int|sys||symlinkat(const char *path1, int fd, \ |
985 | const char *path2); } | | 985 | const char *path2); } |
986 | 471 STD RUMP { int|sys||unlinkat(int fd, const char *path, \ | | 986 | 471 STD RUMP { int|sys||unlinkat(int fd, const char *path, \ |
987 | int flag); } | | 987 | int flag); } |
988 | 472 STD RUMP { int|sys||futimens(int fd, \ | | 988 | 472 STD RUMP { int|sys||futimens(int fd, \ |
989 | const struct timespec *tptr); } | | 989 | const struct timespec *tptr); } |
990 | 473 STD RUMP { int|sys||__quotactl(const char *path, \ | | 990 | 473 STD RUMP { int|sys||__quotactl(const char *path, \ |
991 | struct quotactl_args *args); } | | 991 | struct quotactl_args *args); } |
992 | 474 NOERR { int|sys||posix_spawn(pid_t *pid, const char *path, \ | | 992 | 474 NOERR { int|sys||posix_spawn(pid_t *pid, const char *path, \ |
993 | const struct posix_spawn_file_actions *file_actions, \ | | 993 | const struct posix_spawn_file_actions *file_actions, \ |
994 | const struct posix_spawnattr *attrp, \ | | 994 | const struct posix_spawnattr *attrp, \ |
995 | char *const *argv, char *const *envp); } | | 995 | char *const *argv, char *const *envp); } |
996 | 475 STD RUMP { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, \ | | 996 | 475 STD RUMP { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, \ |
997 | unsigned int vlen, unsigned int flags, \ | | 997 | unsigned int vlen, unsigned int flags, \ |
998 | struct timespec *timeout); } | | 998 | struct timespec *timeout); } |
999 | 476 STD RUMP { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, \ | | 999 | 476 STD RUMP { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, \ |
1000 | unsigned int vlen, unsigned int flags); } | | 1000 | unsigned int vlen, unsigned int flags); } |
1001 | 477 NOERR RUMP { int|sys||clock_nanosleep(clockid_t clock_id, \ | | 1001 | 477 NOERR RUMP { int|sys||clock_nanosleep(clockid_t clock_id, \ |
1002 | int flags, const struct timespec *rqtp, \ | | 1002 | int flags, const struct timespec *rqtp, \ |
1003 | struct timespec *rmtp); } | | 1003 | struct timespec *rmtp); } |
1004 | 478 STD { int|sys|60|_lwp_park(clockid_t clock_id, int flags, \ | | 1004 | 478 STD { int|sys|60|_lwp_park(clockid_t clock_id, int flags, \ |
1005 | struct timespec *ts, lwpid_t unpark, \ | | 1005 | struct timespec *ts, lwpid_t unpark, \ |
1006 | const void *hint, const void *unparkhint); } | | 1006 | const void *hint, const void *unparkhint); } |
1007 | 479 NOERR RUMP { int|sys||posix_fallocate(int fd, int PAD, off_t pos, \ | | 1007 | 479 NOERR RUMP { int|sys||posix_fallocate(int fd, int PAD, off_t pos, \ |
1008 | off_t len); } | | 1008 | off_t len); } |
1009 | 480 STD RUMP { int|sys||fdiscard(int fd, int PAD, off_t pos, \ | | 1009 | 480 STD RUMP { int|sys||fdiscard(int fd, int PAD, off_t pos, \ |
1010 | off_t len); } | | 1010 | off_t len); } |
1011 | 481 STD { int|sys||wait6(idtype_t idtype, id_t id, \ | | 1011 | 481 STD { int|sys||wait6(idtype_t idtype, id_t id, \ |
1012 | int *status, int options, struct wrusage *wru, \ | | 1012 | int *status, int options, struct wrusage *wru, \ |
1013 | siginfo_t *info); } | | 1013 | siginfo_t *info); } |
1014 | 482 STD { int|sys||clock_getcpuclockid2(idtype_t idtype, \ | | 1014 | 482 STD RUMP { int|sys||clock_getcpuclockid2(idtype_t idtype, \ |
1015 | id_t id, clockid_t *clock_id); } | | 1015 | id_t id, clockid_t *clock_id); } |
1016 | 483 STD RUMP { int|sys|90|getvfsstat(struct statvfs *buf, \ | | 1016 | 483 STD RUMP { int|sys|90|getvfsstat(struct statvfs *buf, \ |
1017 | size_t bufsize, int flags); } | | 1017 | size_t bufsize, int flags); } |
1018 | 484 STD RUMP { int|sys|90|statvfs1(const char *path, \ | | 1018 | 484 STD RUMP { int|sys|90|statvfs1(const char *path, \ |
1019 | struct statvfs *buf, int flags); } | | 1019 | struct statvfs *buf, int flags); } |
1020 | 485 STD RUMP { int|sys|90|fstatvfs1(int fd, \ | | 1020 | 485 STD RUMP { int|sys|90|fstatvfs1(int fd, \ |
1021 | struct statvfs *buf, int flags); } | | 1021 | struct statvfs *buf, int flags); } |
1022 | 486 STD RUMP { int|sys|90|fhstatvfs1(const void *fhp, \ | | 1022 | 486 STD RUMP { int|sys|90|fhstatvfs1(const void *fhp, \ |
1023 | size_t fh_size, struct statvfs *buf, int flags); } | | 1023 | size_t fh_size, struct statvfs *buf, int flags); } |
1024 | 487 STD { int|sys||__acl_get_link(const char *path, \ | | 1024 | 487 STD { int|sys||__acl_get_link(const char *path, \ |
1025 | acl_type_t type, struct acl *aclp); } | | 1025 | acl_type_t type, struct acl *aclp); } |
1026 | 488 STD { int|sys||__acl_set_link(const char *path, \ | | 1026 | 488 STD { int|sys||__acl_set_link(const char *path, \ |
1027 | acl_type_t type, struct acl *aclp); } | | 1027 | acl_type_t type, struct acl *aclp); } |
1028 | 489 STD { int|sys||__acl_delete_link(const char *path, \ | | 1028 | 489 STD { int|sys||__acl_delete_link(const char *path, \ |
1029 | acl_type_t type); } | | 1029 | acl_type_t type); } |
1030 | 490 STD { int|sys||__acl_aclcheck_link(const char *path, \ | | 1030 | 490 STD { int|sys||__acl_aclcheck_link(const char *path, \ |
1031 | acl_type_t type, struct acl *aclp); } | | 1031 | acl_type_t type, struct acl *aclp); } |
1032 | 491 STD { int|sys||__acl_get_file(const char *path, \ | | 1032 | 491 STD { int|sys||__acl_get_file(const char *path, \ |
1033 | acl_type_t type, struct acl *aclp); } | | 1033 | acl_type_t type, struct acl *aclp); } |
1034 | 492 STD { int|sys||__acl_set_file(const char *path, \ | | 1034 | 492 STD { int|sys||__acl_set_file(const char *path, \ |
1035 | acl_type_t type, struct acl *aclp); } | | 1035 | acl_type_t type, struct acl *aclp); } |
1036 | 493 STD { int|sys||__acl_get_fd(int filedes, acl_type_t type, \ | | 1036 | 493 STD { int|sys||__acl_get_fd(int filedes, acl_type_t type, \ |
1037 | struct acl *aclp); } | | 1037 | struct acl *aclp); } |
1038 | 494 STD { int|sys||__acl_set_fd(int filedes, acl_type_t type, \ | | 1038 | 494 STD { int|sys||__acl_set_fd(int filedes, acl_type_t type, \ |
1039 | struct acl *aclp); } | | 1039 | struct acl *aclp); } |
1040 | 495 STD { int|sys||__acl_delete_file(const char *path, \ | | 1040 | 495 STD { int|sys||__acl_delete_file(const char *path, \ |
1041 | acl_type_t type); } | | 1041 | acl_type_t type); } |
1042 | 496 STD { int|sys||__acl_delete_fd(int filedes, \ | | 1042 | 496 STD { int|sys||__acl_delete_fd(int filedes, \ |
1043 | acl_type_t type); } | | 1043 | acl_type_t type); } |
1044 | 497 STD { int|sys||__acl_aclcheck_file(const char *path, \ | | 1044 | 497 STD { int|sys||__acl_aclcheck_file(const char *path, \ |
1045 | acl_type_t type, struct acl *aclp); } | | 1045 | acl_type_t type, struct acl *aclp); } |
1046 | 498 STD { int|sys||__acl_aclcheck_fd(int filedes, \ | | 1046 | 498 STD { int|sys||__acl_aclcheck_fd(int filedes, \ |
1047 | acl_type_t type, struct acl *aclp); } | | 1047 | acl_type_t type, struct acl *aclp); } |
1048 | 499 STD RUMP { long|sys||lpathconf(const char *path, int name); } | | 1048 | 499 STD RUMP { long|sys||lpathconf(const char *path, int name); } |