Wed Mar 18 17:30:25 2009 UTC ()
regen: arg -> callarg


(pooka)
diff -r1.30 -r1.31 src/sys/rump/librump/rumpkern/rump_syscalls.c
cvs diff -r1.30 -r1.31 src/sys/rump/librump/rumpkern/rump_syscalls.c (switch to unified diff)

--- src/sys/rump/librump/rumpkern/rump_syscalls.c 2009/03/18 10:22:44 1.30
+++ src/sys/rump/librump/rumpkern/rump_syscalls.c 2009/03/18 17:30:25 1.31
@@ -1,2129 +1,2129 @@ @@ -1,2129 +1,2129 @@
1/* $NetBSD: rump_syscalls.c,v 1.30 2009/03/18 10:22:44 cegger Exp $ */ 1/* $NetBSD: rump_syscalls.c,v 1.31 2009/03/18 17:30:25 pooka Exp $ */
2 2
3/* 3/*
4 * System call vector and marshalling for rump. 4 * System call vector and marshalling for rump.
5 * 5 *
6 * DO NOT EDIT-- this file is automatically generated. 6 * DO NOT EDIT-- this file is automatically generated.
7 * created from NetBSD: syscalls.master,v 1.223 2009/02/13 22:41:04 apb Exp 7 * created from NetBSD: syscalls.master,v 1.223 2009/02/13 22:41:04 apb Exp
8 */ 8 */
9 9
10#include <sys/cdefs.h> 10#include <sys/cdefs.h>
11__KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.30 2009/03/18 10:22:44 cegger Exp $"); 11__KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.31 2009/03/18 17:30:25 pooka Exp $");
12 12
13#include <sys/types.h> 13#include <sys/types.h>
14#include <sys/param.h> 14#include <sys/param.h>
15#include <sys/proc.h> 15#include <sys/proc.h>
16#include <sys/syscall.h> 16#include <sys/syscall.h>
17#include <sys/syscallargs.h> 17#include <sys/syscallargs.h>
18#include <rump/rumpuser.h> 18#include <rump/rumpuser.h>
19#include "rump_private.h" 19#include "rump_private.h"
20 20
21#if BYTE_ORDER == BIG_ENDIAN 21#if BYTE_ORDER == BIG_ENDIAN
22#define SPARG(p,k) ((p)->k.be.datum) 22#define SPARG(p,k) ((p)->k.be.datum)
23#else /* LITTLE_ENDIAN, I hope dearly */ 23#else /* LITTLE_ENDIAN, I hope dearly */
24#define SPARG(p,k) ((p)->k.le.datum) 24#define SPARG(p,k) ((p)->k.le.datum)
25#endif 25#endif
26 26
27int rump_enosys(void); 27int rump_enosys(void);
28int 28int
29rump_enosys(void) 29rump_enosys()
30{ 30{
31 31
32 return ENOSYS; 32 return ENOSYS;
33} 33}
34 34
35ssize_t rump_sys_read(int, void *, size_t); 35ssize_t rump_sys_read(int, void *, size_t);
36ssize_t 36ssize_t
37rump_sys_read(int fd, void * buf, size_t nbyte) 37rump_sys_read(int fd, void * buf, size_t nbyte)
38{ 38{
39 register_t retval = 0; 39 register_t retval = 0;
40 int error = 0; 40 int error = 0;
41 struct sys_read_args arg; 41 struct sys_read_args callarg;
42 42
43 SPARG(&arg, fd) = fd; 43 SPARG(&callarg, fd) = fd;
44 SPARG(&arg, buf) = buf; 44 SPARG(&callarg, buf) = buf;
45 SPARG(&arg, nbyte) = nbyte; 45 SPARG(&callarg, nbyte) = nbyte;
46 46
47 error = rump_sysproxy(SYS_read, rump_sysproxy_arg, 47 error = rump_sysproxy(SYS_read, rump_sysproxy_arg,
48 (uint8_t *)&arg, sizeof(arg), &retval); 48 (uint8_t *)&callarg, sizeof(callarg), &retval);
49 if (error) { 49 if (error) {
50 retval = -1; 50 retval = -1;
51 rumpuser_seterrno(error); 51 rumpuser_seterrno(error);
52 } 52 }
53 return retval; 53 return retval;
54} 54}
55__weak_alias(sys_read,rump_enosys); 55__weak_alias(sys_read,rump_enosys);
56 56
57ssize_t rump_sys_write(int, const void *, size_t); 57ssize_t rump_sys_write(int, const void *, size_t);
58ssize_t 58ssize_t
59rump_sys_write(int fd, const void * buf, size_t nbyte) 59rump_sys_write(int fd, const void * buf, size_t nbyte)
60{ 60{
61 register_t retval = 0; 61 register_t retval = 0;
62 int error = 0; 62 int error = 0;
63 struct sys_write_args arg; 63 struct sys_write_args callarg;
64 64
65 SPARG(&arg, fd) = fd; 65 SPARG(&callarg, fd) = fd;
66 SPARG(&arg, buf) = buf; 66 SPARG(&callarg, buf) = buf;
67 SPARG(&arg, nbyte) = nbyte; 67 SPARG(&callarg, nbyte) = nbyte;
68 68
69 error = rump_sysproxy(SYS_write, rump_sysproxy_arg, 69 error = rump_sysproxy(SYS_write, rump_sysproxy_arg,
70 (uint8_t *)&arg, sizeof(arg), &retval); 70 (uint8_t *)&callarg, sizeof(callarg), &retval);
71 if (error) { 71 if (error) {
72 retval = -1; 72 retval = -1;
73 rumpuser_seterrno(error); 73 rumpuser_seterrno(error);
74 } 74 }
75 return retval; 75 return retval;
76} 76}
77__weak_alias(sys_write,rump_enosys); 77__weak_alias(sys_write,rump_enosys);
78 78
79int rump_sys_open(const char *, int, mode_t); 79int rump_sys_open(const char *, int, mode_t);
80int 80int
81rump_sys_open(const char * path, int flags, mode_t mode) 81rump_sys_open(const char * path, int flags, mode_t mode)
82{ 82{
83 register_t retval = 0; 83 register_t retval = 0;
84 int error = 0; 84 int error = 0;
85 struct sys_open_args arg; 85 struct sys_open_args callarg;
86 86
87 SPARG(&arg, path) = path; 87 SPARG(&callarg, path) = path;
88 SPARG(&arg, flags) = flags; 88 SPARG(&callarg, flags) = flags;
89 SPARG(&arg, mode) = mode; 89 SPARG(&callarg, mode) = mode;
90 90
91 error = rump_sysproxy(SYS_open, rump_sysproxy_arg, 91 error = rump_sysproxy(SYS_open, rump_sysproxy_arg,
92 (uint8_t *)&arg, sizeof(arg), &retval); 92 (uint8_t *)&callarg, sizeof(callarg), &retval);
93 if (error) { 93 if (error) {
94 retval = -1; 94 retval = -1;
95 rumpuser_seterrno(error); 95 rumpuser_seterrno(error);
96 } 96 }
97 return retval; 97 return retval;
98} 98}
99__weak_alias(sys_open,rump_enosys); 99__weak_alias(sys_open,rump_enosys);
100 100
101int rump_sys_close(int); 101int rump_sys_close(int);
102int 102int
103rump_sys_close(int fd) 103rump_sys_close(int fd)
104{ 104{
105 register_t retval = 0; 105 register_t retval = 0;
106 int error = 0; 106 int error = 0;
107 struct sys_close_args arg; 107 struct sys_close_args callarg;
108 108
109 SPARG(&arg, fd) = fd; 109 SPARG(&callarg, fd) = fd;
110 110
111 error = rump_sysproxy(SYS_close, rump_sysproxy_arg, 111 error = rump_sysproxy(SYS_close, rump_sysproxy_arg,
112 (uint8_t *)&arg, sizeof(arg), &retval); 112 (uint8_t *)&callarg, sizeof(callarg), &retval);
113 if (error) { 113 if (error) {
114 retval = -1; 114 retval = -1;
115 rumpuser_seterrno(error); 115 rumpuser_seterrno(error);
116 } 116 }
117 return retval; 117 return retval;
118} 118}
119__weak_alias(sys_close,rump_enosys); 119__weak_alias(sys_close,rump_enosys);
120 120
121int rump_sys_link(const char *, const char *); 121int rump_sys_link(const char *, const char *);
122int 122int
123rump_sys_link(const char * path, const char * link) 123rump_sys_link(const char * path, const char * link)
124{ 124{
125 register_t retval = 0; 125 register_t retval = 0;
126 int error = 0; 126 int error = 0;
127 struct sys_link_args arg; 127 struct sys_link_args callarg;
128 128
129 SPARG(&arg, path) = path; 129 SPARG(&callarg, path) = path;
130 SPARG(&arg, link) = link; 130 SPARG(&callarg, link) = link;
131 131
132 error = rump_sysproxy(SYS_link, rump_sysproxy_arg, 132 error = rump_sysproxy(SYS_link, rump_sysproxy_arg,
133 (uint8_t *)&arg, sizeof(arg), &retval); 133 (uint8_t *)&callarg, sizeof(callarg), &retval);
134 if (error) { 134 if (error) {
135 retval = -1; 135 retval = -1;
136 rumpuser_seterrno(error); 136 rumpuser_seterrno(error);
137 } 137 }
138 return retval; 138 return retval;
139} 139}
140__weak_alias(sys_link,rump_enosys); 140__weak_alias(sys_link,rump_enosys);
141 141
142int rump_sys_unlink(const char *); 142int rump_sys_unlink(const char *);
143int 143int
144rump_sys_unlink(const char * path) 144rump_sys_unlink(const char * path)
145{ 145{
146 register_t retval = 0; 146 register_t retval = 0;
147 int error = 0; 147 int error = 0;
148 struct sys_unlink_args arg; 148 struct sys_unlink_args callarg;
149 149
150 SPARG(&arg, path) = path; 150 SPARG(&callarg, path) = path;
151 151
152 error = rump_sysproxy(SYS_unlink, rump_sysproxy_arg, 152 error = rump_sysproxy(SYS_unlink, rump_sysproxy_arg,
153 (uint8_t *)&arg, sizeof(arg), &retval); 153 (uint8_t *)&callarg, sizeof(callarg), &retval);
154 if (error) { 154 if (error) {
155 retval = -1; 155 retval = -1;
156 rumpuser_seterrno(error); 156 rumpuser_seterrno(error);
157 } 157 }
158 return retval; 158 return retval;
159} 159}
160__weak_alias(sys_unlink,rump_enosys); 160__weak_alias(sys_unlink,rump_enosys);
161 161
162int rump_sys_chdir(const char *); 162int rump_sys_chdir(const char *);
163int 163int
164rump_sys_chdir(const char * path) 164rump_sys_chdir(const char * path)
165{ 165{
166 register_t retval = 0; 166 register_t retval = 0;
167 int error = 0; 167 int error = 0;
168 struct sys_chdir_args arg; 168 struct sys_chdir_args callarg;
169 169
170 SPARG(&arg, path) = path; 170 SPARG(&callarg, path) = path;
171 171
172 error = rump_sysproxy(SYS_chdir, rump_sysproxy_arg, 172 error = rump_sysproxy(SYS_chdir, rump_sysproxy_arg,
173 (uint8_t *)&arg, sizeof(arg), &retval); 173 (uint8_t *)&callarg, sizeof(callarg), &retval);
174 if (error) { 174 if (error) {
175 retval = -1; 175 retval = -1;
176 rumpuser_seterrno(error); 176 rumpuser_seterrno(error);
177 } 177 }
178 return retval; 178 return retval;
179} 179}
180__weak_alias(sys_chdir,rump_enosys); 180__weak_alias(sys_chdir,rump_enosys);
181 181
182int rump_sys_fchdir(int); 182int rump_sys_fchdir(int);
183int 183int
184rump_sys_fchdir(int fd) 184rump_sys_fchdir(int fd)
185{ 185{
186 register_t retval = 0; 186 register_t retval = 0;
187 int error = 0; 187 int error = 0;
188 struct sys_fchdir_args arg; 188 struct sys_fchdir_args callarg;
189 189
190 SPARG(&arg, fd) = fd; 190 SPARG(&callarg, fd) = fd;
191 191
192 error = rump_sysproxy(SYS_fchdir, rump_sysproxy_arg, 192 error = rump_sysproxy(SYS_fchdir, rump_sysproxy_arg,
193 (uint8_t *)&arg, sizeof(arg), &retval); 193 (uint8_t *)&callarg, sizeof(callarg), &retval);
194 if (error) { 194 if (error) {
195 retval = -1; 195 retval = -1;
196 rumpuser_seterrno(error); 196 rumpuser_seterrno(error);
197 } 197 }
198 return retval; 198 return retval;
199} 199}
200__weak_alias(sys_fchdir,rump_enosys); 200__weak_alias(sys_fchdir,rump_enosys);
201 201
202int rump_sys_chmod(const char *, mode_t); 202int rump_sys_chmod(const char *, mode_t);
203int 203int
204rump_sys_chmod(const char * path, mode_t mode) 204rump_sys_chmod(const char * path, mode_t mode)
205{ 205{
206 register_t retval = 0; 206 register_t retval = 0;
207 int error = 0; 207 int error = 0;
208 struct sys_chmod_args arg; 208 struct sys_chmod_args callarg;
209 209
210 SPARG(&arg, path) = path; 210 SPARG(&callarg, path) = path;
211 SPARG(&arg, mode) = mode; 211 SPARG(&callarg, mode) = mode;
212 212
213 error = rump_sysproxy(SYS_chmod, rump_sysproxy_arg, 213 error = rump_sysproxy(SYS_chmod, rump_sysproxy_arg,
214 (uint8_t *)&arg, sizeof(arg), &retval); 214 (uint8_t *)&callarg, sizeof(callarg), &retval);
215 if (error) { 215 if (error) {
216 retval = -1; 216 retval = -1;
217 rumpuser_seterrno(error); 217 rumpuser_seterrno(error);
218 } 218 }
219 return retval; 219 return retval;
220} 220}
221__weak_alias(sys_chmod,rump_enosys); 221__weak_alias(sys_chmod,rump_enosys);
222 222
223int rump_sys_chown(const char *, uid_t, gid_t); 223int rump_sys_chown(const char *, uid_t, gid_t);
224int 224int
225rump_sys_chown(const char * path, uid_t uid, gid_t gid) 225rump_sys_chown(const char * path, uid_t uid, gid_t gid)
226{ 226{
227 register_t retval = 0; 227 register_t retval = 0;
228 int error = 0; 228 int error = 0;
229 struct sys_chown_args arg; 229 struct sys_chown_args callarg;
230 230
231 SPARG(&arg, path) = path; 231 SPARG(&callarg, path) = path;
232 SPARG(&arg, uid) = uid; 232 SPARG(&callarg, uid) = uid;
233 SPARG(&arg, gid) = gid; 233 SPARG(&callarg, gid) = gid;
234 234
235 error = rump_sysproxy(SYS_chown, rump_sysproxy_arg, 235 error = rump_sysproxy(SYS_chown, rump_sysproxy_arg,
236 (uint8_t *)&arg, sizeof(arg), &retval); 236 (uint8_t *)&callarg, sizeof(callarg), &retval);
237 if (error) { 237 if (error) {
238 retval = -1; 238 retval = -1;
239 rumpuser_seterrno(error); 239 rumpuser_seterrno(error);
240 } 240 }
241 return retval; 241 return retval;
242} 242}
243__weak_alias(sys_chown,rump_enosys); 243__weak_alias(sys_chown,rump_enosys);
244 244
245int rump_sys_unmount(const char *, int); 245int rump_sys_unmount(const char *, int);
246int 246int
247rump_sys_unmount(const char * path, int flags) 247rump_sys_unmount(const char * path, int flags)
248{ 248{
249 register_t retval = 0; 249 register_t retval = 0;
250 int error = 0; 250 int error = 0;
251 struct sys_unmount_args arg; 251 struct sys_unmount_args callarg;
252 252
253 SPARG(&arg, path) = path; 253 SPARG(&callarg, path) = path;
254 SPARG(&arg, flags) = flags; 254 SPARG(&callarg, flags) = flags;
255 255
256 error = rump_sysproxy(SYS_unmount, rump_sysproxy_arg, 256 error = rump_sysproxy(SYS_unmount, rump_sysproxy_arg,
257 (uint8_t *)&arg, sizeof(arg), &retval); 257 (uint8_t *)&callarg, sizeof(callarg), &retval);
258 if (error) { 258 if (error) {
259 retval = -1; 259 retval = -1;
260 rumpuser_seterrno(error); 260 rumpuser_seterrno(error);
261 } 261 }
262 return retval; 262 return retval;
263} 263}
264__weak_alias(sys_unmount,rump_enosys); 264__weak_alias(sys_unmount,rump_enosys);
265 265
266ssize_t rump_sys_recvmsg(int, struct msghdr *, int); 266ssize_t rump_sys_recvmsg(int, struct msghdr *, int);
267ssize_t 267ssize_t
268rump_sys_recvmsg(int s, struct msghdr * msg, int flags) 268rump_sys_recvmsg(int s, struct msghdr * msg, int flags)
269{ 269{
270 register_t retval = 0; 270 register_t retval = 0;
271 int error = 0; 271 int error = 0;
272 struct sys_recvmsg_args arg; 272 struct sys_recvmsg_args callarg;
273 273
274 SPARG(&arg, s) = s; 274 SPARG(&callarg, s) = s;
275 SPARG(&arg, msg) = msg; 275 SPARG(&callarg, msg) = msg;
276 SPARG(&arg, flags) = flags; 276 SPARG(&callarg, flags) = flags;
277 277
278 error = rump_sysproxy(SYS_recvmsg, rump_sysproxy_arg, 278 error = rump_sysproxy(SYS_recvmsg, rump_sysproxy_arg,
279 (uint8_t *)&arg, sizeof(arg), &retval); 279 (uint8_t *)&callarg, sizeof(callarg), &retval);
280 if (error) { 280 if (error) {
281 retval = -1; 281 retval = -1;
282 rumpuser_seterrno(error); 282 rumpuser_seterrno(error);
283 } 283 }
284 return retval; 284 return retval;
285} 285}
286__weak_alias(sys_recvmsg,rump_enosys); 286__weak_alias(sys_recvmsg,rump_enosys);
287 287
288ssize_t rump_sys_sendmsg(int, const struct msghdr *, int); 288ssize_t rump_sys_sendmsg(int, const struct msghdr *, int);
289ssize_t 289ssize_t
290rump_sys_sendmsg(int s, const struct msghdr * msg, int flags) 290rump_sys_sendmsg(int s, const struct msghdr * msg, int flags)
291{ 291{
292 register_t retval = 0; 292 register_t retval = 0;
293 int error = 0; 293 int error = 0;
294 struct sys_sendmsg_args arg; 294 struct sys_sendmsg_args callarg;
295 295
296 SPARG(&arg, s) = s; 296 SPARG(&callarg, s) = s;
297 SPARG(&arg, msg) = msg; 297 SPARG(&callarg, msg) = msg;
298 SPARG(&arg, flags) = flags; 298 SPARG(&callarg, flags) = flags;
299 299
300 error = rump_sysproxy(SYS_sendmsg, rump_sysproxy_arg, 300 error = rump_sysproxy(SYS_sendmsg, rump_sysproxy_arg,
301 (uint8_t *)&arg, sizeof(arg), &retval); 301 (uint8_t *)&callarg, sizeof(callarg), &retval);
302 if (error) { 302 if (error) {
303 retval = -1; 303 retval = -1;
304 rumpuser_seterrno(error); 304 rumpuser_seterrno(error);
305 } 305 }
306 return retval; 306 return retval;
307} 307}
308__weak_alias(sys_sendmsg,rump_enosys); 308__weak_alias(sys_sendmsg,rump_enosys);
309 309
310ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *); 310ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *);
311ssize_t 311ssize_t
312rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr) 312rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr)
313{ 313{
314 register_t retval = 0; 314 register_t retval = 0;
315 int error = 0; 315 int error = 0;
316 struct sys_recvfrom_args arg; 316 struct sys_recvfrom_args callarg;
317 317
318 SPARG(&arg, s) = s; 318 SPARG(&callarg, s) = s;
319 SPARG(&arg, buf) = buf; 319 SPARG(&callarg, buf) = buf;
320 SPARG(&arg, len) = len; 320 SPARG(&callarg, len) = len;
321 SPARG(&arg, flags) = flags; 321 SPARG(&callarg, flags) = flags;
322 SPARG(&arg, from) = from; 322 SPARG(&callarg, from) = from;
323 SPARG(&arg, fromlenaddr) = fromlenaddr; 323 SPARG(&callarg, fromlenaddr) = fromlenaddr;
324 324
325 error = rump_sysproxy(SYS_recvfrom, rump_sysproxy_arg, 325 error = rump_sysproxy(SYS_recvfrom, rump_sysproxy_arg,
326 (uint8_t *)&arg, sizeof(arg), &retval); 326 (uint8_t *)&callarg, sizeof(callarg), &retval);
327 if (error) { 327 if (error) {
328 retval = -1; 328 retval = -1;
329 rumpuser_seterrno(error); 329 rumpuser_seterrno(error);
330 } 330 }
331 return retval; 331 return retval;
332} 332}
333__weak_alias(sys_recvfrom,rump_enosys); 333__weak_alias(sys_recvfrom,rump_enosys);
334 334
335int rump_sys_accept(int, struct sockaddr *, unsigned int *); 335int rump_sys_accept(int, struct sockaddr *, unsigned int *);
336int 336int
337rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen) 337rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen)
338{ 338{
339 register_t retval = 0; 339 register_t retval = 0;
340 int error = 0; 340 int error = 0;
341 struct sys_accept_args arg; 341 struct sys_accept_args callarg;
342 342
343 SPARG(&arg, s) = s; 343 SPARG(&callarg, s) = s;
344 SPARG(&arg, name) = name; 344 SPARG(&callarg, name) = name;
345 SPARG(&arg, anamelen) = anamelen; 345 SPARG(&callarg, anamelen) = anamelen;
346 346
347 error = rump_sysproxy(SYS_accept, rump_sysproxy_arg, 347 error = rump_sysproxy(SYS_accept, rump_sysproxy_arg,
348 (uint8_t *)&arg, sizeof(arg), &retval); 348 (uint8_t *)&callarg, sizeof(callarg), &retval);
349 if (error) { 349 if (error) {
350 retval = -1; 350 retval = -1;
351 rumpuser_seterrno(error); 351 rumpuser_seterrno(error);
352 } 352 }
353 return retval; 353 return retval;
354} 354}
355__weak_alias(sys_accept,rump_enosys); 355__weak_alias(sys_accept,rump_enosys);
356 356
357int rump_sys_getpeername(int, struct sockaddr *, unsigned int *); 357int rump_sys_getpeername(int, struct sockaddr *, unsigned int *);
358int 358int
359rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen) 359rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen)
360{ 360{
361 register_t retval = 0; 361 register_t retval = 0;
362 int error = 0; 362 int error = 0;
363 struct sys_getpeername_args arg; 363 struct sys_getpeername_args callarg;
364 364
365 SPARG(&arg, fdes) = fdes; 365 SPARG(&callarg, fdes) = fdes;
366 SPARG(&arg, asa) = asa; 366 SPARG(&callarg, asa) = asa;
367 SPARG(&arg, alen) = alen; 367 SPARG(&callarg, alen) = alen;
368 368
369 error = rump_sysproxy(SYS_getpeername, rump_sysproxy_arg, 369 error = rump_sysproxy(SYS_getpeername, rump_sysproxy_arg,
370 (uint8_t *)&arg, sizeof(arg), &retval); 370 (uint8_t *)&callarg, sizeof(callarg), &retval);
371 if (error) { 371 if (error) {
372 retval = -1; 372 retval = -1;
373 rumpuser_seterrno(error); 373 rumpuser_seterrno(error);
374 } 374 }
375 return retval; 375 return retval;
376} 376}
377__weak_alias(sys_getpeername,rump_enosys); 377__weak_alias(sys_getpeername,rump_enosys);
378 378
379int rump_sys_getsockname(int, struct sockaddr *, unsigned int *); 379int rump_sys_getsockname(int, struct sockaddr *, unsigned int *);
380int 380int
381rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen) 381rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen)
382{ 382{
383 register_t retval = 0; 383 register_t retval = 0;
384 int error = 0; 384 int error = 0;
385 struct sys_getsockname_args arg; 385 struct sys_getsockname_args callarg;
386 386
387 SPARG(&arg, fdes) = fdes; 387 SPARG(&callarg, fdes) = fdes;
388 SPARG(&arg, asa) = asa; 388 SPARG(&callarg, asa) = asa;
389 SPARG(&arg, alen) = alen; 389 SPARG(&callarg, alen) = alen;
390 390
391 error = rump_sysproxy(SYS_getsockname, rump_sysproxy_arg, 391 error = rump_sysproxy(SYS_getsockname, rump_sysproxy_arg,
392 (uint8_t *)&arg, sizeof(arg), &retval); 392 (uint8_t *)&callarg, sizeof(callarg), &retval);
393 if (error) { 393 if (error) {
394 retval = -1; 394 retval = -1;
395 rumpuser_seterrno(error); 395 rumpuser_seterrno(error);
396 } 396 }
397 return retval; 397 return retval;
398} 398}
399__weak_alias(sys_getsockname,rump_enosys); 399__weak_alias(sys_getsockname,rump_enosys);
400 400
401int rump_sys_chflags(const char *, u_long); 401int rump_sys_chflags(const char *, u_long);
402int 402int
403rump_sys_chflags(const char * path, u_long flags) 403rump_sys_chflags(const char * path, u_long flags)
404{ 404{
405 register_t retval = 0; 405 register_t retval = 0;
406 int error = 0; 406 int error = 0;
407 struct sys_chflags_args arg; 407 struct sys_chflags_args callarg;
408 408
409 SPARG(&arg, path) = path; 409 SPARG(&callarg, path) = path;
410 SPARG(&arg, flags) = flags; 410 SPARG(&callarg, flags) = flags;
411 411
412 error = rump_sysproxy(SYS_chflags, rump_sysproxy_arg, 412 error = rump_sysproxy(SYS_chflags, rump_sysproxy_arg,
413 (uint8_t *)&arg, sizeof(arg), &retval); 413 (uint8_t *)&callarg, sizeof(callarg), &retval);
414 if (error) { 414 if (error) {
415 retval = -1; 415 retval = -1;
416 rumpuser_seterrno(error); 416 rumpuser_seterrno(error);
417 } 417 }
418 return retval; 418 return retval;
419} 419}
420__weak_alias(sys_chflags,rump_enosys); 420__weak_alias(sys_chflags,rump_enosys);
421 421
422void rump_sys_sync(void); 422void rump_sys_sync(void);
423void 423void
424rump_sys_sync(void ) 424rump_sys_sync(void )
425{ 425{
426 register_t retval = 0; 426 register_t retval = 0;
427 int error = 0; 427 int error = 0;
428 428
429 error = rump_sysproxy(SYS_sync, rump_sysproxy_arg, 429 error = rump_sysproxy(SYS_sync, rump_sysproxy_arg,
430 (uint8_t *)NULL, 0, &retval); 430 (uint8_t *)NULL, 0, &retval);
431 if (error) { 431 if (error) {
432 retval = -1; 432 retval = -1;
433 } 433 }
434} 434}
435__weak_alias(sys_sync,rump_enosys); 435__weak_alias(sys_sync,rump_enosys);
436 436
437int rump_sys_ioctl(int, u_long, void *); 437int rump_sys_ioctl(int, u_long, void *);
438int 438int
439rump_sys_ioctl(int fd, u_long com, void * data) 439rump_sys_ioctl(int fd, u_long com, void * data)
440{ 440{
441 register_t retval = 0; 441 register_t retval = 0;
442 int error = 0; 442 int error = 0;
443 struct sys_ioctl_args arg; 443 struct sys_ioctl_args callarg;
444 444
445 SPARG(&arg, fd) = fd; 445 SPARG(&callarg, fd) = fd;
446 SPARG(&arg, com) = com; 446 SPARG(&callarg, com) = com;
447 SPARG(&arg, data) = data; 447 SPARG(&callarg, data) = data;
448 448
449 error = rump_sysproxy(SYS_ioctl, rump_sysproxy_arg, 449 error = rump_sysproxy(SYS_ioctl, rump_sysproxy_arg,
450 (uint8_t *)&arg, sizeof(arg), &retval); 450 (uint8_t *)&callarg, sizeof(callarg), &retval);
451 if (error) { 451 if (error) {
452 retval = -1; 452 retval = -1;
453 rumpuser_seterrno(error); 453 rumpuser_seterrno(error);
454 } 454 }
455 return retval; 455 return retval;
456} 456}
457__weak_alias(sys_ioctl,rump_enosys); 457__weak_alias(sys_ioctl,rump_enosys);
458 458
459int rump_sys_symlink(const char *, const char *); 459int rump_sys_symlink(const char *, const char *);
460int 460int
461rump_sys_symlink(const char * path, const char * link) 461rump_sys_symlink(const char * path, const char * link)
462{ 462{
463 register_t retval = 0; 463 register_t retval = 0;
464 int error = 0; 464 int error = 0;
465 struct sys_symlink_args arg; 465 struct sys_symlink_args callarg;
466 466
467 SPARG(&arg, path) = path; 467 SPARG(&callarg, path) = path;
468 SPARG(&arg, link) = link; 468 SPARG(&callarg, link) = link;
469 469
470 error = rump_sysproxy(SYS_symlink, rump_sysproxy_arg, 470 error = rump_sysproxy(SYS_symlink, rump_sysproxy_arg,
471 (uint8_t *)&arg, sizeof(arg), &retval); 471 (uint8_t *)&callarg, sizeof(callarg), &retval);
472 if (error) { 472 if (error) {
473 retval = -1; 473 retval = -1;
474 rumpuser_seterrno(error); 474 rumpuser_seterrno(error);
475 } 475 }
476 return retval; 476 return retval;
477} 477}
478__weak_alias(sys_symlink,rump_enosys); 478__weak_alias(sys_symlink,rump_enosys);
479 479
480ssize_t rump_sys_readlink(const char *, char *, size_t); 480ssize_t rump_sys_readlink(const char *, char *, size_t);
481ssize_t 481ssize_t
482rump_sys_readlink(const char * path, char * buf, size_t count) 482rump_sys_readlink(const char * path, char * buf, size_t count)
483{ 483{
484 register_t retval = 0; 484 register_t retval = 0;
485 int error = 0; 485 int error = 0;
486 struct sys_readlink_args arg; 486 struct sys_readlink_args callarg;
487 487
488 SPARG(&arg, path) = path; 488 SPARG(&callarg, path) = path;
489 SPARG(&arg, buf) = buf; 489 SPARG(&callarg, buf) = buf;
490 SPARG(&arg, count) = count; 490 SPARG(&callarg, count) = count;
491 491
492 error = rump_sysproxy(SYS_readlink, rump_sysproxy_arg, 492 error = rump_sysproxy(SYS_readlink, rump_sysproxy_arg,
493 (uint8_t *)&arg, sizeof(arg), &retval); 493 (uint8_t *)&callarg, sizeof(callarg), &retval);
494 if (error) { 494 if (error) {
495 retval = -1; 495 retval = -1;
496 rumpuser_seterrno(error); 496 rumpuser_seterrno(error);
497 } 497 }
498 return retval; 498 return retval;
499} 499}
500__weak_alias(sys_readlink,rump_enosys); 500__weak_alias(sys_readlink,rump_enosys);
501 501
502int rump_sys_fsync(int); 502int rump_sys_fsync(int);
503int 503int
504rump_sys_fsync(int fd) 504rump_sys_fsync(int fd)
505{ 505{
506 register_t retval = 0; 506 register_t retval = 0;
507 int error = 0; 507 int error = 0;
508 struct sys_fsync_args arg; 508 struct sys_fsync_args callarg;
509 509
510 SPARG(&arg, fd) = fd; 510 SPARG(&callarg, fd) = fd;
511 511
512 error = rump_sysproxy(SYS_fsync, rump_sysproxy_arg, 512 error = rump_sysproxy(SYS_fsync, rump_sysproxy_arg,
513 (uint8_t *)&arg, sizeof(arg), &retval); 513 (uint8_t *)&callarg, sizeof(callarg), &retval);
514 if (error) { 514 if (error) {
515 retval = -1; 515 retval = -1;
516 rumpuser_seterrno(error); 516 rumpuser_seterrno(error);
517 } 517 }
518 return retval; 518 return retval;
519} 519}
520__weak_alias(sys_fsync,rump_enosys); 520__weak_alias(sys_fsync,rump_enosys);
521 521
522int rump_sys_connect(int, const struct sockaddr *, unsigned int); 522int rump_sys_connect(int, const struct sockaddr *, unsigned int);
523int 523int
524rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen) 524rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen)
525{ 525{
526 register_t retval = 0; 526 register_t retval = 0;
527 int error = 0; 527 int error = 0;
528 struct sys_connect_args arg; 528 struct sys_connect_args callarg;
529 529
530 SPARG(&arg, s) = s; 530 SPARG(&callarg, s) = s;
531 SPARG(&arg, name) = name; 531 SPARG(&callarg, name) = name;
532 SPARG(&arg, namelen) = namelen; 532 SPARG(&callarg, namelen) = namelen;
533 533
534 error = rump_sysproxy(SYS_connect, rump_sysproxy_arg, 534 error = rump_sysproxy(SYS_connect, rump_sysproxy_arg,
535 (uint8_t *)&arg, sizeof(arg), &retval); 535 (uint8_t *)&callarg, sizeof(callarg), &retval);
536 if (error) { 536 if (error) {
537 retval = -1; 537 retval = -1;
538 rumpuser_seterrno(error); 538 rumpuser_seterrno(error);
539 } 539 }
540 return retval; 540 return retval;
541} 541}
542__weak_alias(sys_connect,rump_enosys); 542__weak_alias(sys_connect,rump_enosys);
543 543
544int rump_sys_bind(int, const struct sockaddr *, unsigned int); 544int rump_sys_bind(int, const struct sockaddr *, unsigned int);
545int 545int
546rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen) 546rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen)
547{ 547{
548 register_t retval = 0; 548 register_t retval = 0;
549 int error = 0; 549 int error = 0;
550 struct sys_bind_args arg; 550 struct sys_bind_args callarg;
551 551
552 SPARG(&arg, s) = s; 552 SPARG(&callarg, s) = s;
553 SPARG(&arg, name) = name; 553 SPARG(&callarg, name) = name;
554 SPARG(&arg, namelen) = namelen; 554 SPARG(&callarg, namelen) = namelen;
555 555
556 error = rump_sysproxy(SYS_bind, rump_sysproxy_arg, 556 error = rump_sysproxy(SYS_bind, rump_sysproxy_arg,
557 (uint8_t *)&arg, sizeof(arg), &retval); 557 (uint8_t *)&callarg, sizeof(callarg), &retval);
558 if (error) { 558 if (error) {
559 retval = -1; 559 retval = -1;
560 rumpuser_seterrno(error); 560 rumpuser_seterrno(error);
561 } 561 }
562 return retval; 562 return retval;
563} 563}
564__weak_alias(sys_bind,rump_enosys); 564__weak_alias(sys_bind,rump_enosys);
565 565
566int rump_sys_setsockopt(int, int, int, const void *, unsigned int); 566int rump_sys_setsockopt(int, int, int, const void *, unsigned int);
567int 567int
568rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize) 568rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize)
569{ 569{
570 register_t retval = 0; 570 register_t retval = 0;
571 int error = 0; 571 int error = 0;
572 struct sys_setsockopt_args arg; 572 struct sys_setsockopt_args callarg;
573 573
574 SPARG(&arg, s) = s; 574 SPARG(&callarg, s) = s;
575 SPARG(&arg, level) = level; 575 SPARG(&callarg, level) = level;
576 SPARG(&arg, name) = name; 576 SPARG(&callarg, name) = name;
577 SPARG(&arg, val) = val; 577 SPARG(&callarg, val) = val;
578 SPARG(&arg, valsize) = valsize; 578 SPARG(&callarg, valsize) = valsize;
579 579
580 error = rump_sysproxy(SYS_setsockopt, rump_sysproxy_arg, 580 error = rump_sysproxy(SYS_setsockopt, rump_sysproxy_arg,
581 (uint8_t *)&arg, sizeof(arg), &retval); 581 (uint8_t *)&callarg, sizeof(callarg), &retval);
582 if (error) { 582 if (error) {
583 retval = -1; 583 retval = -1;
584 rumpuser_seterrno(error); 584 rumpuser_seterrno(error);
585 } 585 }
586 return retval; 586 return retval;
587} 587}
588__weak_alias(sys_setsockopt,rump_enosys); 588__weak_alias(sys_setsockopt,rump_enosys);
589 589
590int rump_sys_listen(int, int); 590int rump_sys_listen(int, int);
591int 591int
592rump_sys_listen(int s, int backlog) 592rump_sys_listen(int s, int backlog)
593{ 593{
594 register_t retval = 0; 594 register_t retval = 0;
595 int error = 0; 595 int error = 0;
596 struct sys_listen_args arg; 596 struct sys_listen_args callarg;
597 597
598 SPARG(&arg, s) = s; 598 SPARG(&callarg, s) = s;
599 SPARG(&arg, backlog) = backlog; 599 SPARG(&callarg, backlog) = backlog;
600 600
601 error = rump_sysproxy(SYS_listen, rump_sysproxy_arg, 601 error = rump_sysproxy(SYS_listen, rump_sysproxy_arg,
602 (uint8_t *)&arg, sizeof(arg), &retval); 602 (uint8_t *)&callarg, sizeof(callarg), &retval);
603 if (error) { 603 if (error) {
604 retval = -1; 604 retval = -1;
605 rumpuser_seterrno(error); 605 rumpuser_seterrno(error);
606 } 606 }
607 return retval; 607 return retval;
608} 608}
609__weak_alias(sys_listen,rump_enosys); 609__weak_alias(sys_listen,rump_enosys);
610 610
611int rump_sys_getsockopt(int, int, int, void *, unsigned int *); 611int rump_sys_getsockopt(int, int, int, void *, unsigned int *);
612int 612int
613rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize) 613rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize)
614{ 614{
615 register_t retval = 0; 615 register_t retval = 0;
616 int error = 0; 616 int error = 0;
617 struct sys_getsockopt_args arg; 617 struct sys_getsockopt_args callarg;
618 618
619 SPARG(&arg, s) = s; 619 SPARG(&callarg, s) = s;
620 SPARG(&arg, level) = level; 620 SPARG(&callarg, level) = level;
621 SPARG(&arg, name) = name; 621 SPARG(&callarg, name) = name;
622 SPARG(&arg, val) = val; 622 SPARG(&callarg, val) = val;
623 SPARG(&arg, avalsize) = avalsize; 623 SPARG(&callarg, avalsize) = avalsize;
624 624
625 error = rump_sysproxy(SYS_getsockopt, rump_sysproxy_arg, 625 error = rump_sysproxy(SYS_getsockopt, rump_sysproxy_arg,
626 (uint8_t *)&arg, sizeof(arg), &retval); 626 (uint8_t *)&callarg, sizeof(callarg), &retval);
627 if (error) { 627 if (error) {
628 retval = -1; 628 retval = -1;
629 rumpuser_seterrno(error); 629 rumpuser_seterrno(error);
630 } 630 }
631 return retval; 631 return retval;
632} 632}
633__weak_alias(sys_getsockopt,rump_enosys); 633__weak_alias(sys_getsockopt,rump_enosys);
634 634
635int rump_sys_rename(const char *, const char *); 635int rump_sys_rename(const char *, const char *);
636int 636int
637rump_sys_rename(const char * from, const char * to) 637rump_sys_rename(const char * from, const char * to)
638{ 638{
639 register_t retval = 0; 639 register_t retval = 0;
640 int error = 0; 640 int error = 0;
641 struct sys_rename_args arg; 641 struct sys_rename_args callarg;
642 642
643 SPARG(&arg, from) = from; 643 SPARG(&callarg, from) = from;
644 SPARG(&arg, to) = to; 644 SPARG(&callarg, to) = to;
645 645
646 error = rump_sysproxy(SYS_rename, rump_sysproxy_arg, 646 error = rump_sysproxy(SYS_rename, rump_sysproxy_arg,
647 (uint8_t *)&arg, sizeof(arg), &retval); 647 (uint8_t *)&callarg, sizeof(callarg), &retval);
648 if (error) { 648 if (error) {
649 retval = -1; 649 retval = -1;
650 rumpuser_seterrno(error); 650 rumpuser_seterrno(error);
651 } 651 }
652 return retval; 652 return retval;
653} 653}
654__weak_alias(sys_rename,rump_enosys); 654__weak_alias(sys_rename,rump_enosys);
655 655
656int rump_sys_mkfifo(const char *, mode_t); 656int rump_sys_mkfifo(const char *, mode_t);
657int 657int
658rump_sys_mkfifo(const char * path, mode_t mode) 658rump_sys_mkfifo(const char * path, mode_t mode)
659{ 659{
660 register_t retval = 0; 660 register_t retval = 0;
661 int error = 0; 661 int error = 0;
662 struct sys_mkfifo_args arg; 662 struct sys_mkfifo_args callarg;
663 663
664 SPARG(&arg, path) = path; 664 SPARG(&callarg, path) = path;
665 SPARG(&arg, mode) = mode; 665 SPARG(&callarg, mode) = mode;
666 666
667 error = rump_sysproxy(SYS_mkfifo, rump_sysproxy_arg, 667 error = rump_sysproxy(SYS_mkfifo, rump_sysproxy_arg,
668 (uint8_t *)&arg, sizeof(arg), &retval); 668 (uint8_t *)&callarg, sizeof(callarg), &retval);
669 if (error) { 669 if (error) {
670 retval = -1; 670 retval = -1;
671 rumpuser_seterrno(error); 671 rumpuser_seterrno(error);
672 } 672 }
673 return retval; 673 return retval;
674} 674}
675__weak_alias(sys_mkfifo,rump_enosys); 675__weak_alias(sys_mkfifo,rump_enosys);
676 676
677ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int); 677ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int);
678ssize_t 678ssize_t
679rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen) 679rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen)
680{ 680{
681 register_t retval = 0; 681 register_t retval = 0;
682 int error = 0; 682 int error = 0;
683 struct sys_sendto_args arg; 683 struct sys_sendto_args callarg;
684 684
685 SPARG(&arg, s) = s; 685 SPARG(&callarg, s) = s;
686 SPARG(&arg, buf) = buf; 686 SPARG(&callarg, buf) = buf;
687 SPARG(&arg, len) = len; 687 SPARG(&callarg, len) = len;
688 SPARG(&arg, flags) = flags; 688 SPARG(&callarg, flags) = flags;
689 SPARG(&arg, to) = to; 689 SPARG(&callarg, to) = to;
690 SPARG(&arg, tolen) = tolen; 690 SPARG(&callarg, tolen) = tolen;
691 691
692 error = rump_sysproxy(SYS_sendto, rump_sysproxy_arg, 692 error = rump_sysproxy(SYS_sendto, rump_sysproxy_arg,
693 (uint8_t *)&arg, sizeof(arg), &retval); 693 (uint8_t *)&callarg, sizeof(callarg), &retval);
694 if (error) { 694 if (error) {
695 retval = -1; 695 retval = -1;
696 rumpuser_seterrno(error); 696 rumpuser_seterrno(error);
697 } 697 }
698 return retval; 698 return retval;
699} 699}
700__weak_alias(sys_sendto,rump_enosys); 700__weak_alias(sys_sendto,rump_enosys);
701 701
702int rump_sys_shutdown(int, int); 702int rump_sys_shutdown(int, int);
703int 703int
704rump_sys_shutdown(int s, int how) 704rump_sys_shutdown(int s, int how)
705{ 705{
706 register_t retval = 0; 706 register_t retval = 0;
707 int error = 0; 707 int error = 0;
708 struct sys_shutdown_args arg; 708 struct sys_shutdown_args callarg;
709 709
710 SPARG(&arg, s) = s; 710 SPARG(&callarg, s) = s;
711 SPARG(&arg, how) = how; 711 SPARG(&callarg, how) = how;
712 712
713 error = rump_sysproxy(SYS_shutdown, rump_sysproxy_arg, 713 error = rump_sysproxy(SYS_shutdown, rump_sysproxy_arg,
714 (uint8_t *)&arg, sizeof(arg), &retval); 714 (uint8_t *)&callarg, sizeof(callarg), &retval);
715 if (error) { 715 if (error) {
716 retval = -1; 716 retval = -1;
717 rumpuser_seterrno(error); 717 rumpuser_seterrno(error);
718 } 718 }
719 return retval; 719 return retval;
720} 720}
721__weak_alias(sys_shutdown,rump_enosys); 721__weak_alias(sys_shutdown,rump_enosys);
722 722
723int rump_sys_socketpair(int, int, int, int *); 723int rump_sys_socketpair(int, int, int, int *);
724int 724int
725rump_sys_socketpair(int domain, int type, int protocol, int * rsv) 725rump_sys_socketpair(int domain, int type, int protocol, int * rsv)
726{ 726{
727 register_t retval = 0; 727 register_t retval = 0;
728 int error = 0; 728 int error = 0;
729 struct sys_socketpair_args arg; 729 struct sys_socketpair_args callarg;
730 730
731 SPARG(&arg, domain) = domain; 731 SPARG(&callarg, domain) = domain;
732 SPARG(&arg, type) = type; 732 SPARG(&callarg, type) = type;
733 SPARG(&arg, protocol) = protocol; 733 SPARG(&callarg, protocol) = protocol;
734 SPARG(&arg, rsv) = rsv; 734 SPARG(&callarg, rsv) = rsv;
735 735
736 error = rump_sysproxy(SYS_socketpair, rump_sysproxy_arg, 736 error = rump_sysproxy(SYS_socketpair, rump_sysproxy_arg,
737 (uint8_t *)&arg, sizeof(arg), &retval); 737 (uint8_t *)&callarg, sizeof(callarg), &retval);
738 if (error) { 738 if (error) {
739 retval = -1; 739 retval = -1;
740 rumpuser_seterrno(error); 740 rumpuser_seterrno(error);
741 } 741 }
742 return retval; 742 return retval;
743} 743}
744__weak_alias(sys_socketpair,rump_enosys); 744__weak_alias(sys_socketpair,rump_enosys);
745 745
746int rump_sys_mkdir(const char *, mode_t); 746int rump_sys_mkdir(const char *, mode_t);
747int 747int
748rump_sys_mkdir(const char * path, mode_t mode) 748rump_sys_mkdir(const char * path, mode_t mode)
749{ 749{
750 register_t retval = 0; 750 register_t retval = 0;
751 int error = 0; 751 int error = 0;
752 struct sys_mkdir_args arg; 752 struct sys_mkdir_args callarg;
753 753
754 SPARG(&arg, path) = path; 754 SPARG(&callarg, path) = path;
755 SPARG(&arg, mode) = mode; 755 SPARG(&callarg, mode) = mode;
756 756
757 error = rump_sysproxy(SYS_mkdir, rump_sysproxy_arg, 757 error = rump_sysproxy(SYS_mkdir, rump_sysproxy_arg,
758 (uint8_t *)&arg, sizeof(arg), &retval); 758 (uint8_t *)&callarg, sizeof(callarg), &retval);
759 if (error) { 759 if (error) {
760 retval = -1; 760 retval = -1;
761 rumpuser_seterrno(error); 761 rumpuser_seterrno(error);
762 } 762 }
763 return retval; 763 return retval;
764} 764}
765__weak_alias(sys_mkdir,rump_enosys); 765__weak_alias(sys_mkdir,rump_enosys);
766 766
767int rump_sys_rmdir(const char *); 767int rump_sys_rmdir(const char *);
768int 768int
769rump_sys_rmdir(const char * path) 769rump_sys_rmdir(const char * path)
770{ 770{
771 register_t retval = 0; 771 register_t retval = 0;
772 int error = 0; 772 int error = 0;
773 struct sys_rmdir_args arg; 773 struct sys_rmdir_args callarg;
774 774
775 SPARG(&arg, path) = path; 775 SPARG(&callarg, path) = path;
776 776
777 error = rump_sysproxy(SYS_rmdir, rump_sysproxy_arg, 777 error = rump_sysproxy(SYS_rmdir, rump_sysproxy_arg,
778 (uint8_t *)&arg, sizeof(arg), &retval); 778 (uint8_t *)&callarg, sizeof(callarg), &retval);
779 if (error) { 779 if (error) {
780 retval = -1; 780 retval = -1;
781 rumpuser_seterrno(error); 781 rumpuser_seterrno(error);
782 } 782 }
783 return retval; 783 return retval;
784} 784}
785__weak_alias(sys_rmdir,rump_enosys); 785__weak_alias(sys_rmdir,rump_enosys);
786 786
787int rump_sys_nfssvc(int, void *); 787int rump_sys_nfssvc(int, void *);
788int 788int
789rump_sys_nfssvc(int flag, void * argp) 789rump_sys_nfssvc(int flag, void * argp)
790{ 790{
791 register_t retval = 0; 791 register_t retval = 0;
792 int error = 0; 792 int error = 0;
793 struct sys_nfssvc_args arg; 793 struct sys_nfssvc_args callarg;
794 794
795 SPARG(&arg, flag) = flag; 795 SPARG(&callarg, flag) = flag;
796 SPARG(&arg, argp) = argp; 796 SPARG(&callarg, argp) = argp;
797 797
798 error = rump_sysproxy(SYS_nfssvc, rump_sysproxy_arg, 798 error = rump_sysproxy(SYS_nfssvc, rump_sysproxy_arg,
799 (uint8_t *)&arg, sizeof(arg), &retval); 799 (uint8_t *)&callarg, sizeof(callarg), &retval);
800 if (error) { 800 if (error) {
801 retval = -1; 801 retval = -1;
802 rumpuser_seterrno(error); 802 rumpuser_seterrno(error);
803 } 803 }
804 return retval; 804 return retval;
805} 805}
806__weak_alias(sys_nfssvc,rump_enosys); 806__weak_alias(sys_nfssvc,rump_enosys);
807 807
808ssize_t rump_sys_pread(int, void *, size_t, int, off_t); 808ssize_t rump_sys_pread(int, void *, size_t, int, off_t);
809ssize_t 809ssize_t
810rump_sys_pread(int fd, void * buf, size_t nbyte, int pad, off_t offset) 810rump_sys_pread(int fd, void * buf, size_t nbyte, int pad, off_t offset)
811{ 811{
812 register_t retval = 0; 812 register_t retval = 0;
813 int error = 0; 813 int error = 0;
814 struct sys_pread_args arg; 814 struct sys_pread_args callarg;
815 815
816 SPARG(&arg, fd) = fd; 816 SPARG(&callarg, fd) = fd;
817 SPARG(&arg, buf) = buf; 817 SPARG(&callarg, buf) = buf;
818 SPARG(&arg, nbyte) = nbyte; 818 SPARG(&callarg, nbyte) = nbyte;
819 SPARG(&arg, pad) = pad; 819 SPARG(&callarg, pad) = pad;
820 SPARG(&arg, offset) = offset; 820 SPARG(&callarg, offset) = offset;
821 821
822 error = rump_sysproxy(SYS_pread, rump_sysproxy_arg, 822 error = rump_sysproxy(SYS_pread, rump_sysproxy_arg,
823 (uint8_t *)&arg, sizeof(arg), &retval); 823 (uint8_t *)&callarg, sizeof(callarg), &retval);
824 if (error) { 824 if (error) {
825 retval = -1; 825 retval = -1;
826 rumpuser_seterrno(error); 826 rumpuser_seterrno(error);
827 } 827 }
828 return retval; 828 return retval;
829} 829}
830__weak_alias(sys_pread,rump_enosys); 830__weak_alias(sys_pread,rump_enosys);
831 831
832ssize_t rump_sys_pwrite(int, const void *, size_t, int, off_t); 832ssize_t rump_sys_pwrite(int, const void *, size_t, int, off_t);
833ssize_t 833ssize_t
834rump_sys_pwrite(int fd, const void * buf, size_t nbyte, int pad, off_t offset) 834rump_sys_pwrite(int fd, const void * buf, size_t nbyte, int pad, off_t offset)
835{ 835{
836 register_t retval = 0; 836 register_t retval = 0;
837 int error = 0; 837 int error = 0;
838 struct sys_pwrite_args arg; 838 struct sys_pwrite_args callarg;
839 839
840 SPARG(&arg, fd) = fd; 840 SPARG(&callarg, fd) = fd;
841 SPARG(&arg, buf) = buf; 841 SPARG(&callarg, buf) = buf;
842 SPARG(&arg, nbyte) = nbyte; 842 SPARG(&callarg, nbyte) = nbyte;
843 SPARG(&arg, pad) = pad; 843 SPARG(&callarg, pad) = pad;
844 SPARG(&arg, offset) = offset; 844 SPARG(&callarg, offset) = offset;
845 845
846 error = rump_sysproxy(SYS_pwrite, rump_sysproxy_arg, 846 error = rump_sysproxy(SYS_pwrite, rump_sysproxy_arg,
847 (uint8_t *)&arg, sizeof(arg), &retval); 847 (uint8_t *)&callarg, sizeof(callarg), &retval);
848 if (error) { 848 if (error) {
849 retval = -1; 849 retval = -1;
850 rumpuser_seterrno(error); 850 rumpuser_seterrno(error);
851 } 851 }
852 return retval; 852 return retval;
853} 853}
854__weak_alias(sys_pwrite,rump_enosys); 854__weak_alias(sys_pwrite,rump_enosys);
855 855
856int rump_sys_truncate(const char *, int, off_t); 856int rump_sys_truncate(const char *, int, off_t);
857int 857int
858rump_sys_truncate(const char * path, int pad, off_t length) 858rump_sys_truncate(const char * path, int pad, off_t length)
859{ 859{
860 register_t retval = 0; 860 register_t retval = 0;
861 int error = 0; 861 int error = 0;
862 struct sys_truncate_args arg; 862 struct sys_truncate_args callarg;
863 863
864 SPARG(&arg, path) = path; 864 SPARG(&callarg, path) = path;
865 SPARG(&arg, pad) = pad; 865 SPARG(&callarg, pad) = pad;
866 SPARG(&arg, length) = length; 866 SPARG(&callarg, length) = length;
867 867
868 error = rump_sysproxy(SYS_truncate, rump_sysproxy_arg, 868 error = rump_sysproxy(SYS_truncate, rump_sysproxy_arg,
869 (uint8_t *)&arg, sizeof(arg), &retval); 869 (uint8_t *)&callarg, sizeof(callarg), &retval);
870 if (error) { 870 if (error) {
871 retval = -1; 871 retval = -1;
872 rumpuser_seterrno(error); 872 rumpuser_seterrno(error);
873 } 873 }
874 return retval; 874 return retval;
875} 875}
876__weak_alias(sys_truncate,rump_enosys); 876__weak_alias(sys_truncate,rump_enosys);
877 877
878int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 878int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t);
879int 879int
880rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 880rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen)
881{ 881{
882 register_t retval = 0; 882 register_t retval = 0;
883 int error = 0; 883 int error = 0;
884 struct sys___sysctl_args arg; 884 struct sys___sysctl_args callarg;
885 885
886 SPARG(&arg, name) = name; 886 SPARG(&callarg, name) = name;
887 SPARG(&arg, namelen) = namelen; 887 SPARG(&callarg, namelen) = namelen;
888 SPARG(&arg, old) = old; 888 SPARG(&callarg, old) = old;
889 SPARG(&arg, oldlenp) = oldlenp; 889 SPARG(&callarg, oldlenp) = oldlenp;
890 SPARG(&arg, new) = new; 890 SPARG(&callarg, new) = new;
891 SPARG(&arg, newlen) = newlen; 891 SPARG(&callarg, newlen) = newlen;
892 892
893 error = rump_sysproxy(SYS___sysctl, rump_sysproxy_arg, 893 error = rump_sysproxy(SYS___sysctl, rump_sysproxy_arg,
894 (uint8_t *)&arg, sizeof(arg), &retval); 894 (uint8_t *)&callarg, sizeof(callarg), &retval);
895 if (error) { 895 if (error) {
896 retval = -1; 896 retval = -1;
897 rumpuser_seterrno(error); 897 rumpuser_seterrno(error);
898 } 898 }
899 return retval; 899 return retval;
900} 900}
901__weak_alias(sys___sysctl,rump_enosys); 901__weak_alias(sys___sysctl,rump_enosys);
902 902
903int rump_sys_lchmod(const char *, mode_t); 903int rump_sys_lchmod(const char *, mode_t);
904int 904int
905rump_sys_lchmod(const char * path, mode_t mode) 905rump_sys_lchmod(const char * path, mode_t mode)
906{ 906{
907 register_t retval = 0; 907 register_t retval = 0;
908 int error = 0; 908 int error = 0;
909 struct sys_lchmod_args arg; 909 struct sys_lchmod_args callarg;
910 910
911 SPARG(&arg, path) = path; 911 SPARG(&callarg, path) = path;
912 SPARG(&arg, mode) = mode; 912 SPARG(&callarg, mode) = mode;
913 913
914 error = rump_sysproxy(SYS_lchmod, rump_sysproxy_arg, 914 error = rump_sysproxy(SYS_lchmod, rump_sysproxy_arg,
915 (uint8_t *)&arg, sizeof(arg), &retval); 915 (uint8_t *)&callarg, sizeof(callarg), &retval);
916 if (error) { 916 if (error) {
917 retval = -1; 917 retval = -1;
918 rumpuser_seterrno(error); 918 rumpuser_seterrno(error);
919 } 919 }
920 return retval; 920 return retval;
921} 921}
922__weak_alias(sys_lchmod,rump_enosys); 922__weak_alias(sys_lchmod,rump_enosys);
923 923
924int rump_sys_lchown(const char *, uid_t, gid_t); 924int rump_sys_lchown(const char *, uid_t, gid_t);
925int 925int
926rump_sys_lchown(const char * path, uid_t uid, gid_t gid) 926rump_sys_lchown(const char * path, uid_t uid, gid_t gid)
927{ 927{
928 register_t retval = 0; 928 register_t retval = 0;
929 int error = 0; 929 int error = 0;
930 struct sys_lchown_args arg; 930 struct sys_lchown_args callarg;
931 931
932 SPARG(&arg, path) = path; 932 SPARG(&callarg, path) = path;
933 SPARG(&arg, uid) = uid; 933 SPARG(&callarg, uid) = uid;
934 SPARG(&arg, gid) = gid; 934 SPARG(&callarg, gid) = gid;
935 935
936 error = rump_sysproxy(SYS_lchown, rump_sysproxy_arg, 936 error = rump_sysproxy(SYS_lchown, rump_sysproxy_arg,
937 (uint8_t *)&arg, sizeof(arg), &retval); 937 (uint8_t *)&callarg, sizeof(callarg), &retval);
938 if (error) { 938 if (error) {
939 retval = -1; 939 retval = -1;
940 rumpuser_seterrno(error); 940 rumpuser_seterrno(error);
941 } 941 }
942 return retval; 942 return retval;
943} 943}
944__weak_alias(sys_lchown,rump_enosys); 944__weak_alias(sys_lchown,rump_enosys);
945 945
946int rump_sys_lchflags(const char *, u_long); 946int rump_sys_lchflags(const char *, u_long);
947int 947int
948rump_sys_lchflags(const char * path, u_long flags) 948rump_sys_lchflags(const char * path, u_long flags)
949{ 949{
950 register_t retval = 0; 950 register_t retval = 0;
951 int error = 0; 951 int error = 0;
952 struct sys_lchflags_args arg; 952 struct sys_lchflags_args callarg;
953 953
954 SPARG(&arg, path) = path; 954 SPARG(&callarg, path) = path;
955 SPARG(&arg, flags) = flags; 955 SPARG(&callarg, flags) = flags;
956 956
957 error = rump_sysproxy(SYS_lchflags, rump_sysproxy_arg, 957 error = rump_sysproxy(SYS_lchflags, rump_sysproxy_arg,
958 (uint8_t *)&arg, sizeof(arg), &retval); 958 (uint8_t *)&callarg, sizeof(callarg), &retval);
959 if (error) { 959 if (error) {
960 retval = -1; 960 retval = -1;
961 rumpuser_seterrno(error); 961 rumpuser_seterrno(error);
962 } 962 }
963 return retval; 963 return retval;
964} 964}
965__weak_alias(sys_lchflags,rump_enosys); 965__weak_alias(sys_lchflags,rump_enosys);
966 966
967int rump_sys_statvfs1(const char *, struct statvfs *, int); 967int rump_sys_statvfs1(const char *, struct statvfs *, int);
968int 968int
969rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags) 969rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags)
970{ 970{
971 register_t retval = 0; 971 register_t retval = 0;
972 int error = 0; 972 int error = 0;
973 struct sys_statvfs1_args arg; 973 struct sys_statvfs1_args callarg;
974 974
975 SPARG(&arg, path) = path; 975 SPARG(&callarg, path) = path;
976 SPARG(&arg, buf) = buf; 976 SPARG(&callarg, buf) = buf;
977 SPARG(&arg, flags) = flags; 977 SPARG(&callarg, flags) = flags;
978 978
979 error = rump_sysproxy(SYS_statvfs1, rump_sysproxy_arg, 979 error = rump_sysproxy(SYS_statvfs1, rump_sysproxy_arg,
980 (uint8_t *)&arg, sizeof(arg), &retval); 980 (uint8_t *)&callarg, sizeof(callarg), &retval);
981 if (error) { 981 if (error) {
982 retval = -1; 982 retval = -1;
983 rumpuser_seterrno(error); 983 rumpuser_seterrno(error);
984 } 984 }
985 return retval; 985 return retval;
986} 986}
987__weak_alias(sys_statvfs1,rump_enosys); 987__weak_alias(sys_statvfs1,rump_enosys);
988 988
989int rump_sys___socket30(int, int, int); 989int rump_sys___socket30(int, int, int);
990int 990int
991rump_sys___socket30(int domain, int type, int protocol) 991rump_sys___socket30(int domain, int type, int protocol)
992{ 992{
993 register_t retval = 0; 993 register_t retval = 0;
994 int error = 0; 994 int error = 0;
995 struct sys___socket30_args arg; 995 struct sys___socket30_args callarg;
996 996
997 SPARG(&arg, domain) = domain; 997 SPARG(&callarg, domain) = domain;
998 SPARG(&arg, type) = type; 998 SPARG(&callarg, type) = type;
999 SPARG(&arg, protocol) = protocol; 999 SPARG(&callarg, protocol) = protocol;
1000 1000
1001 error = rump_sysproxy(SYS___socket30, rump_sysproxy_arg, 1001 error = rump_sysproxy(SYS___socket30, rump_sysproxy_arg,
1002 (uint8_t *)&arg, sizeof(arg), &retval); 1002 (uint8_t *)&callarg, sizeof(callarg), &retval);
1003 if (error) { 1003 if (error) {
1004 retval = -1; 1004 retval = -1;
1005 rumpuser_seterrno(error); 1005 rumpuser_seterrno(error);
1006 } 1006 }
1007 return retval; 1007 return retval;
1008} 1008}
1009__weak_alias(sys___socket30,rump_enosys); 1009__weak_alias(sys___socket30,rump_enosys);
1010 1010
1011int rump_sys___getfh30(const char *, void *, size_t *); 1011int rump_sys___getfh30(const char *, void *, size_t *);
1012int 1012int
1013rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size) 1013rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size)
1014{ 1014{
1015 register_t retval = 0; 1015 register_t retval = 0;
1016 int error = 0; 1016 int error = 0;
1017 struct sys___getfh30_args arg; 1017 struct sys___getfh30_args callarg;
1018 1018
1019 SPARG(&arg, fname) = fname; 1019 SPARG(&callarg, fname) = fname;
1020 SPARG(&arg, fhp) = fhp; 1020 SPARG(&callarg, fhp) = fhp;
1021 SPARG(&arg, fh_size) = fh_size; 1021 SPARG(&callarg, fh_size) = fh_size;
1022 1022
1023 error = rump_sysproxy(SYS___getfh30, rump_sysproxy_arg, 1023 error = rump_sysproxy(SYS___getfh30, rump_sysproxy_arg,
1024 (uint8_t *)&arg, sizeof(arg), &retval); 1024 (uint8_t *)&callarg, sizeof(callarg), &retval);
1025 if (error) { 1025 if (error) {
1026 retval = -1; 1026 retval = -1;
1027 rumpuser_seterrno(error); 1027 rumpuser_seterrno(error);
1028 } 1028 }
1029 return retval; 1029 return retval;
1030} 1030}
1031__weak_alias(sys___getfh30,rump_enosys); 1031__weak_alias(sys___getfh30,rump_enosys);
1032 1032
1033int rump_sys___utimes50(const char *, const struct timeval *); 1033int rump_sys___utimes50(const char *, const struct timeval *);
1034int 1034int
1035rump_sys___utimes50(const char * path, const struct timeval * tptr) 1035rump_sys___utimes50(const char * path, const struct timeval * tptr)
1036{ 1036{
1037 register_t retval = 0; 1037 register_t retval = 0;
1038 int error = 0; 1038 int error = 0;
1039 struct sys___utimes50_args arg; 1039 struct sys___utimes50_args callarg;
1040 1040
1041 SPARG(&arg, path) = path; 1041 SPARG(&callarg, path) = path;
1042 SPARG(&arg, tptr) = tptr; 1042 SPARG(&callarg, tptr) = tptr;
1043 1043
1044 error = rump_sysproxy(SYS___utimes50, rump_sysproxy_arg, 1044 error = rump_sysproxy(SYS___utimes50, rump_sysproxy_arg,
1045 (uint8_t *)&arg, sizeof(arg), &retval); 1045 (uint8_t *)&callarg, sizeof(callarg), &retval);
1046 if (error) { 1046 if (error) {
1047 retval = -1; 1047 retval = -1;
1048 rumpuser_seterrno(error); 1048 rumpuser_seterrno(error);
1049 } 1049 }
1050 return retval; 1050 return retval;
1051} 1051}
1052__weak_alias(sys___utimes50,rump_enosys); 1052__weak_alias(sys___utimes50,rump_enosys);
1053 1053
1054int rump_sys___lutimes50(const char *, const struct timeval *); 1054int rump_sys___lutimes50(const char *, const struct timeval *);
1055int 1055int
1056rump_sys___lutimes50(const char * path, const struct timeval * tptr) 1056rump_sys___lutimes50(const char * path, const struct timeval * tptr)
1057{ 1057{
1058 register_t retval = 0; 1058 register_t retval = 0;
1059 int error = 0; 1059 int error = 0;
1060 struct sys___lutimes50_args arg; 1060 struct sys___lutimes50_args callarg;
1061 1061
1062 SPARG(&arg, path) = path; 1062 SPARG(&callarg, path) = path;
1063 SPARG(&arg, tptr) = tptr; 1063 SPARG(&callarg, tptr) = tptr;
1064 1064
1065 error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg, 1065 error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg,
1066 (uint8_t *)&arg, sizeof(arg), &retval); 1066 (uint8_t *)&callarg, sizeof(callarg), &retval);
1067 if (error) { 1067 if (error) {
1068 retval = -1; 1068 retval = -1;
1069 rumpuser_seterrno(error); 1069 rumpuser_seterrno(error);
1070 } 1070 }
1071 return retval; 1071 return retval;
1072} 1072}
1073__weak_alias(sys___lutimes50,rump_enosys); 1073__weak_alias(sys___lutimes50,rump_enosys);
1074 1074
1075int rump_sys___stat50(const char *, struct stat *); 1075int rump_sys___stat50(const char *, struct stat *);
1076int 1076int
1077rump_sys___stat50(const char * path, struct stat * ub) 1077rump_sys___stat50(const char * path, struct stat * ub)
1078{ 1078{
1079 register_t retval = 0; 1079 register_t retval = 0;
1080 int error = 0; 1080 int error = 0;
1081 struct sys___stat50_args arg; 1081 struct sys___stat50_args callarg;
1082 1082
1083 SPARG(&arg, path) = path; 1083 SPARG(&callarg, path) = path;
1084 SPARG(&arg, ub) = ub; 1084 SPARG(&callarg, ub) = ub;
1085 1085
1086 error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg, 1086 error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg,
1087 (uint8_t *)&arg, sizeof(arg), &retval); 1087 (uint8_t *)&callarg, sizeof(callarg), &retval);
1088 if (error) { 1088 if (error) {
1089 retval = -1; 1089 retval = -1;
1090 rumpuser_seterrno(error); 1090 rumpuser_seterrno(error);
1091 } 1091 }
1092 return retval; 1092 return retval;
1093} 1093}
1094__weak_alias(sys___stat50,rump_enosys); 1094__weak_alias(sys___stat50,rump_enosys);
1095 1095
1096int rump_sys___lstat50(const char *, struct stat *); 1096int rump_sys___lstat50(const char *, struct stat *);
1097int 1097int
1098rump_sys___lstat50(const char * path, struct stat * ub) 1098rump_sys___lstat50(const char * path, struct stat * ub)
1099{ 1099{
1100 register_t retval = 0; 1100 register_t retval = 0;
1101 int error = 0; 1101 int error = 0;
1102 struct sys___lstat50_args arg; 1102 struct sys___lstat50_args callarg;
1103 1103
1104 SPARG(&arg, path) = path; 1104 SPARG(&callarg, path) = path;
1105 SPARG(&arg, ub) = ub; 1105 SPARG(&callarg, ub) = ub;
1106 1106
1107 error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg, 1107 error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg,
1108 (uint8_t *)&arg, sizeof(arg), &retval); 1108 (uint8_t *)&callarg, sizeof(callarg), &retval);
1109 if (error) { 1109 if (error) {
1110 retval = -1; 1110 retval = -1;
1111 rumpuser_seterrno(error); 1111 rumpuser_seterrno(error);
1112 } 1112 }
1113 return retval; 1113 return retval;
1114} 1114}
1115__weak_alias(sys___lstat50,rump_enosys); 1115__weak_alias(sys___lstat50,rump_enosys);
1116 1116
1117int rump_sys___mknod50(const char *, mode_t, dev_t); 1117int rump_sys___mknod50(const char *, mode_t, dev_t);
1118int 1118int
1119rump_sys___mknod50(const char * path, mode_t mode, dev_t dev) 1119rump_sys___mknod50(const char * path, mode_t mode, dev_t dev)
1120{ 1120{
1121 register_t retval = 0; 1121 register_t retval = 0;
1122 int error = 0; 1122 int error = 0;
1123 struct sys___mknod50_args arg; 1123 struct sys___mknod50_args callarg;
1124 1124
1125 SPARG(&arg, path) = path; 1125 SPARG(&callarg, path) = path;
1126 SPARG(&arg, mode) = mode; 1126 SPARG(&callarg, mode) = mode;
1127 SPARG(&arg, dev) = dev; 1127 SPARG(&callarg, dev) = dev;
1128 1128
1129 error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg, 1129 error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg,
1130 (uint8_t *)&arg, sizeof(arg), &retval); 1130 (uint8_t *)&callarg, sizeof(callarg), &retval);
1131 if (error) { 1131 if (error) {
1132 retval = -1; 1132 retval = -1;
1133 rumpuser_seterrno(error); 1133 rumpuser_seterrno(error);
1134 } 1134 }
1135 return retval; 1135 return retval;
1136} 1136}
1137__weak_alias(sys___mknod50,rump_enosys); 1137__weak_alias(sys___mknod50,rump_enosys);
1138 1138
1139#define s(type) sizeof(type) 1139#define s(type) sizeof(type)
1140#define n(type) (sizeof(type)/sizeof (register_t)) 1140#define n(type) (sizeof(type)/sizeof (register_t))
1141#define ns(type) n(type), s(type) 1141#define ns(type) n(type), s(type)
1142 1142
1143struct sysent rump_sysent[] = { 1143struct sysent rump_sysent[] = {
1144 { 0, 0, 0, 1144 { 0, 0, 0,
1145 (sy_call_t *)rump_enosys }, /* 0 = unrumped */ 1145 (sy_call_t *)rump_enosys }, /* 0 = unrumped */
1146 { 0, 0, 0, 1146 { 0, 0, 0,
1147 (sy_call_t *)rump_enosys }, /* 1 = unrumped */ 1147 (sy_call_t *)rump_enosys }, /* 1 = unrumped */
1148 { 0, 0, 0, 1148 { 0, 0, 0,
1149 (sy_call_t *)rump_enosys }, /* 2 = unrumped */ 1149 (sy_call_t *)rump_enosys }, /* 2 = unrumped */
1150 { ns(struct sys_read_args), 0, 1150 { ns(struct sys_read_args), 0,
1151 (sy_call_t *)sys_read }, /* 3 = read */ 1151 (sy_call_t *)sys_read }, /* 3 = read */
1152 { ns(struct sys_write_args), 0, 1152 { ns(struct sys_write_args), 0,
1153 (sy_call_t *)sys_write }, /* 4 = write */ 1153 (sy_call_t *)sys_write }, /* 4 = write */
1154 { ns(struct sys_open_args), 0, 1154 { ns(struct sys_open_args), 0,
1155 (sy_call_t *)sys_open }, /* 5 = open */ 1155 (sy_call_t *)sys_open }, /* 5 = open */
1156 { ns(struct sys_close_args), 0, 1156 { ns(struct sys_close_args), 0,
1157 (sy_call_t *)sys_close }, /* 6 = close */ 1157 (sy_call_t *)sys_close }, /* 6 = close */
1158 { 0, 0, 0, 1158 { 0, 0, 0,
1159 (sy_call_t *)rump_enosys }, /* 7 = unrumped */ 1159 (sy_call_t *)rump_enosys }, /* 7 = unrumped */
1160 { 0, 0, 0, 1160 { 0, 0, 0,
1161 (sy_call_t *)rump_enosys }, /* 8 = unrumped */ 1161 (sy_call_t *)rump_enosys }, /* 8 = unrumped */
1162 { ns(struct sys_link_args), 0, 1162 { ns(struct sys_link_args), 0,
1163 (sy_call_t *)sys_link }, /* 9 = link */ 1163 (sy_call_t *)sys_link }, /* 9 = link */
1164 { ns(struct sys_unlink_args), 0, 1164 { ns(struct sys_unlink_args), 0,
1165 (sy_call_t *)sys_unlink }, /* 10 = unlink */ 1165 (sy_call_t *)sys_unlink }, /* 10 = unlink */
1166 { 0, 0, 0, 1166 { 0, 0, 0,
1167 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 1167 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */
1168 { ns(struct sys_chdir_args), 0, 1168 { ns(struct sys_chdir_args), 0,
1169 (sy_call_t *)sys_chdir }, /* 12 = chdir */ 1169 (sy_call_t *)sys_chdir }, /* 12 = chdir */
1170 { ns(struct sys_fchdir_args), 0, 1170 { ns(struct sys_fchdir_args), 0,
1171 (sy_call_t *)sys_fchdir }, /* 13 = fchdir */ 1171 (sy_call_t *)sys_fchdir }, /* 13 = fchdir */
1172 { 0, 0, 0, 1172 { 0, 0, 0,
1173 (sy_call_t *)rump_enosys }, /* 14 = unrumped */ 1173 (sy_call_t *)rump_enosys }, /* 14 = unrumped */
1174 { ns(struct sys_chmod_args), 0, 1174 { ns(struct sys_chmod_args), 0,
1175 (sy_call_t *)sys_chmod }, /* 15 = chmod */ 1175 (sy_call_t *)sys_chmod }, /* 15 = chmod */
1176 { ns(struct sys_chown_args), 0, 1176 { ns(struct sys_chown_args), 0,
1177 (sy_call_t *)sys_chown }, /* 16 = chown */ 1177 (sy_call_t *)sys_chown }, /* 16 = chown */
1178 { 0, 0, 0, 1178 { 0, 0, 0,
1179 (sy_call_t *)rump_enosys }, /* 17 = unrumped */ 1179 (sy_call_t *)rump_enosys }, /* 17 = unrumped */
1180 { 0, 0, 0, 1180 { 0, 0, 0,
1181 (sy_call_t *)rump_enosys }, /* 18 = unrumped */ 1181 (sy_call_t *)rump_enosys }, /* 18 = unrumped */
1182 { 0, 0, 0, 1182 { 0, 0, 0,
1183 (sy_call_t *)rump_enosys }, /* 19 = unrumped */ 1183 (sy_call_t *)rump_enosys }, /* 19 = unrumped */
1184 { 0, 0, 0, 1184 { 0, 0, 0,
1185 (sy_call_t *)rump_enosys }, /* 20 = unrumped */ 1185 (sy_call_t *)rump_enosys }, /* 20 = unrumped */
1186 { 0, 0, 0, 1186 { 0, 0, 0,
1187 (sy_call_t *)rump_enosys }, /* 21 = unrumped */ 1187 (sy_call_t *)rump_enosys }, /* 21 = unrumped */
1188 { ns(struct sys_unmount_args), 0, 1188 { ns(struct sys_unmount_args), 0,
1189 (sy_call_t *)sys_unmount }, /* 22 = unmount */ 1189 (sy_call_t *)sys_unmount }, /* 22 = unmount */
1190 { 0, 0, 0, 1190 { 0, 0, 0,
1191 (sy_call_t *)rump_enosys }, /* 23 = unrumped */ 1191 (sy_call_t *)rump_enosys }, /* 23 = unrumped */
1192 { 0, 0, 0, 1192 { 0, 0, 0,
1193 (sy_call_t *)rump_enosys }, /* 24 = unrumped */ 1193 (sy_call_t *)rump_enosys }, /* 24 = unrumped */
1194 { 0, 0, 0, 1194 { 0, 0, 0,
1195 (sy_call_t *)rump_enosys }, /* 25 = unrumped */ 1195 (sy_call_t *)rump_enosys }, /* 25 = unrumped */
1196 { 0, 0, 0, 1196 { 0, 0, 0,
1197 (sy_call_t *)rump_enosys }, /* 26 = unrumped */ 1197 (sy_call_t *)rump_enosys }, /* 26 = unrumped */
1198 { ns(struct sys_recvmsg_args), 0, 1198 { ns(struct sys_recvmsg_args), 0,
1199 (sy_call_t *)sys_recvmsg }, /* 27 = recvmsg */ 1199 (sy_call_t *)sys_recvmsg }, /* 27 = recvmsg */
1200 { ns(struct sys_sendmsg_args), 0, 1200 { ns(struct sys_sendmsg_args), 0,
1201 (sy_call_t *)sys_sendmsg }, /* 28 = sendmsg */ 1201 (sy_call_t *)sys_sendmsg }, /* 28 = sendmsg */
1202 { ns(struct sys_recvfrom_args), 0, 1202 { ns(struct sys_recvfrom_args), 0,
1203 (sy_call_t *)sys_recvfrom }, /* 29 = recvfrom */ 1203 (sy_call_t *)sys_recvfrom }, /* 29 = recvfrom */
1204 { ns(struct sys_accept_args), 0, 1204 { ns(struct sys_accept_args), 0,
1205 (sy_call_t *)sys_accept }, /* 30 = accept */ 1205 (sy_call_t *)sys_accept }, /* 30 = accept */
1206 { ns(struct sys_getpeername_args), 0, 1206 { ns(struct sys_getpeername_args), 0,
1207 (sy_call_t *)sys_getpeername }, /* 31 = getpeername */ 1207 (sy_call_t *)sys_getpeername }, /* 31 = getpeername */
1208 { ns(struct sys_getsockname_args), 0, 1208 { ns(struct sys_getsockname_args), 0,
1209 (sy_call_t *)sys_getsockname }, /* 32 = getsockname */ 1209 (sy_call_t *)sys_getsockname }, /* 32 = getsockname */
1210 { 0, 0, 0, 1210 { 0, 0, 0,
1211 (sy_call_t *)rump_enosys }, /* 33 = unrumped */ 1211 (sy_call_t *)rump_enosys }, /* 33 = unrumped */
1212 { ns(struct sys_chflags_args), 0, 1212 { ns(struct sys_chflags_args), 0,
1213 (sy_call_t *)sys_chflags }, /* 34 = chflags */ 1213 (sy_call_t *)sys_chflags }, /* 34 = chflags */
1214 { 0, 0, 0, 1214 { 0, 0, 0,
1215 (sy_call_t *)rump_enosys }, /* 35 = unrumped */ 1215 (sy_call_t *)rump_enosys }, /* 35 = unrumped */
1216 { 0, 0, 0, 1216 { 0, 0, 0,
1217 (sy_call_t *)sys_sync }, /* 36 = sync */ 1217 (sy_call_t *)sys_sync }, /* 36 = sync */
1218 { 0, 0, 0, 1218 { 0, 0, 0,
1219 (sy_call_t *)rump_enosys }, /* 37 = unrumped */ 1219 (sy_call_t *)rump_enosys }, /* 37 = unrumped */
1220 { 0, 0, 0, 1220 { 0, 0, 0,
1221 (sy_call_t *)rump_enosys }, /* 38 = unrumped */ 1221 (sy_call_t *)rump_enosys }, /* 38 = unrumped */
1222 { 0, 0, 0, 1222 { 0, 0, 0,
1223 (sy_call_t *)rump_enosys }, /* 39 = unrumped */ 1223 (sy_call_t *)rump_enosys }, /* 39 = unrumped */
1224 { 0, 0, 0, 1224 { 0, 0, 0,
1225 (sy_call_t *)rump_enosys }, /* 40 = unrumped */ 1225 (sy_call_t *)rump_enosys }, /* 40 = unrumped */
1226 { 0, 0, 0, 1226 { 0, 0, 0,
1227 (sy_call_t *)rump_enosys }, /* 41 = unrumped */ 1227 (sy_call_t *)rump_enosys }, /* 41 = unrumped */
1228 { 0, 0, 0, 1228 { 0, 0, 0,
1229 (sy_call_t *)rump_enosys }, /* 42 = unrumped */ 1229 (sy_call_t *)rump_enosys }, /* 42 = unrumped */
1230 { 0, 0, 0, 1230 { 0, 0, 0,
1231 (sy_call_t *)rump_enosys }, /* 43 = unrumped */ 1231 (sy_call_t *)rump_enosys }, /* 43 = unrumped */
1232 { 0, 0, 0, 1232 { 0, 0, 0,
1233 (sy_call_t *)rump_enosys }, /* 44 = unrumped */ 1233 (sy_call_t *)rump_enosys }, /* 44 = unrumped */
1234 { 0, 0, 0, 1234 { 0, 0, 0,
1235 (sy_call_t *)rump_enosys }, /* 45 = unrumped */ 1235 (sy_call_t *)rump_enosys }, /* 45 = unrumped */
1236 { 0, 0, 0, 1236 { 0, 0, 0,
1237 (sy_call_t *)rump_enosys }, /* 46 = unrumped */ 1237 (sy_call_t *)rump_enosys }, /* 46 = unrumped */
1238 { 0, 0, 0, 1238 { 0, 0, 0,
1239 (sy_call_t *)rump_enosys }, /* 47 = unrumped */ 1239 (sy_call_t *)rump_enosys }, /* 47 = unrumped */
1240 { 0, 0, 0, 1240 { 0, 0, 0,
1241 (sy_call_t *)rump_enosys }, /* 48 = unrumped */ 1241 (sy_call_t *)rump_enosys }, /* 48 = unrumped */
1242 { 0, 0, 0, 1242 { 0, 0, 0,
1243 (sy_call_t *)rump_enosys }, /* 49 = unrumped */ 1243 (sy_call_t *)rump_enosys }, /* 49 = unrumped */
1244 { 0, 0, 0, 1244 { 0, 0, 0,
1245 (sy_call_t *)rump_enosys }, /* 50 = unrumped */ 1245 (sy_call_t *)rump_enosys }, /* 50 = unrumped */
1246 { 0, 0, 0, 1246 { 0, 0, 0,
1247 (sy_call_t *)rump_enosys }, /* 51 = unrumped */ 1247 (sy_call_t *)rump_enosys }, /* 51 = unrumped */
1248 { 0, 0, 0, 1248 { 0, 0, 0,
1249 (sy_call_t *)rump_enosys }, /* 52 = unrumped */ 1249 (sy_call_t *)rump_enosys }, /* 52 = unrumped */
1250 { 0, 0, 0, 1250 { 0, 0, 0,
1251 (sy_call_t *)rump_enosys }, /* 53 = unrumped */ 1251 (sy_call_t *)rump_enosys }, /* 53 = unrumped */
1252 { ns(struct sys_ioctl_args), 0, 1252 { ns(struct sys_ioctl_args), 0,
1253 (sy_call_t *)sys_ioctl }, /* 54 = ioctl */ 1253 (sy_call_t *)sys_ioctl }, /* 54 = ioctl */
1254 { 0, 0, 0, 1254 { 0, 0, 0,
1255 (sy_call_t *)rump_enosys }, /* 55 = unrumped */ 1255 (sy_call_t *)rump_enosys }, /* 55 = unrumped */
1256 { 0, 0, 0, 1256 { 0, 0, 0,
1257 (sy_call_t *)rump_enosys }, /* 56 = unrumped */ 1257 (sy_call_t *)rump_enosys }, /* 56 = unrumped */
1258 { ns(struct sys_symlink_args), 0, 1258 { ns(struct sys_symlink_args), 0,
1259 (sy_call_t *)sys_symlink }, /* 57 = symlink */ 1259 (sy_call_t *)sys_symlink }, /* 57 = symlink */
1260 { ns(struct sys_readlink_args), 0, 1260 { ns(struct sys_readlink_args), 0,
1261 (sy_call_t *)sys_readlink }, /* 58 = readlink */ 1261 (sy_call_t *)sys_readlink }, /* 58 = readlink */
1262 { 0, 0, 0, 1262 { 0, 0, 0,
1263 (sy_call_t *)rump_enosys }, /* 59 = unrumped */ 1263 (sy_call_t *)rump_enosys }, /* 59 = unrumped */
1264 { 0, 0, 0, 1264 { 0, 0, 0,
1265 (sy_call_t *)rump_enosys }, /* 60 = unrumped */ 1265 (sy_call_t *)rump_enosys }, /* 60 = unrumped */
1266 { 0, 0, 0, 1266 { 0, 0, 0,
1267 (sy_call_t *)rump_enosys }, /* 61 = unrumped */ 1267 (sy_call_t *)rump_enosys }, /* 61 = unrumped */
1268 { 0, 0, 0, 1268 { 0, 0, 0,
1269 (sy_call_t *)rump_enosys }, /* 62 = unrumped */ 1269 (sy_call_t *)rump_enosys }, /* 62 = unrumped */
1270 { 0, 0, 0, 1270 { 0, 0, 0,
1271 (sy_call_t *)rump_enosys }, /* 63 = unrumped */ 1271 (sy_call_t *)rump_enosys }, /* 63 = unrumped */
1272 { 0, 0, 0, 1272 { 0, 0, 0,
1273 (sy_call_t *)rump_enosys }, /* 64 = unrumped */ 1273 (sy_call_t *)rump_enosys }, /* 64 = unrumped */
1274 { 0, 0, 0, 1274 { 0, 0, 0,
1275 (sy_call_t *)rump_enosys }, /* 65 = unrumped */ 1275 (sy_call_t *)rump_enosys }, /* 65 = unrumped */
1276 { 0, 0, 0, 1276 { 0, 0, 0,
1277 (sy_call_t *)rump_enosys }, /* 66 = unrumped */ 1277 (sy_call_t *)rump_enosys }, /* 66 = unrumped */
1278 { 0, 0, 0, 1278 { 0, 0, 0,
1279 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 1279 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */
1280 { 0, 0, 0, 1280 { 0, 0, 0,
1281 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 1281 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */
1282 { 0, 0, 0, 1282 { 0, 0, 0,
1283 (sy_call_t *)rump_enosys }, /* 69 = unrumped */ 1283 (sy_call_t *)rump_enosys }, /* 69 = unrumped */
1284 { 0, 0, 0, 1284 { 0, 0, 0,
1285 (sy_call_t *)rump_enosys }, /* 70 = unrumped */ 1285 (sy_call_t *)rump_enosys }, /* 70 = unrumped */
1286 { 0, 0, 0, 1286 { 0, 0, 0,
1287 (sy_call_t *)rump_enosys }, /* 71 = unrumped */ 1287 (sy_call_t *)rump_enosys }, /* 71 = unrumped */
1288 { 0, 0, 0, 1288 { 0, 0, 0,
1289 (sy_call_t *)rump_enosys }, /* 72 = unrumped */ 1289 (sy_call_t *)rump_enosys }, /* 72 = unrumped */
1290 { 0, 0, 0, 1290 { 0, 0, 0,
1291 (sy_call_t *)rump_enosys }, /* 73 = unrumped */ 1291 (sy_call_t *)rump_enosys }, /* 73 = unrumped */
1292 { 0, 0, 0, 1292 { 0, 0, 0,
1293 (sy_call_t *)rump_enosys }, /* 74 = unrumped */ 1293 (sy_call_t *)rump_enosys }, /* 74 = unrumped */
1294 { 0, 0, 0, 1294 { 0, 0, 0,
1295 (sy_call_t *)rump_enosys }, /* 75 = unrumped */ 1295 (sy_call_t *)rump_enosys }, /* 75 = unrumped */
1296 { 0, 0, 0, 1296 { 0, 0, 0,
1297 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 1297 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */
1298 { 0, 0, 0, 1298 { 0, 0, 0,
1299 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 1299 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */
1300 { 0, 0, 0, 1300 { 0, 0, 0,
1301 (sy_call_t *)rump_enosys }, /* 78 = unrumped */ 1301 (sy_call_t *)rump_enosys }, /* 78 = unrumped */
1302 { 0, 0, 0, 1302 { 0, 0, 0,
1303 (sy_call_t *)rump_enosys }, /* 79 = unrumped */ 1303 (sy_call_t *)rump_enosys }, /* 79 = unrumped */
1304 { 0, 0, 0, 1304 { 0, 0, 0,
1305 (sy_call_t *)rump_enosys }, /* 80 = unrumped */ 1305 (sy_call_t *)rump_enosys }, /* 80 = unrumped */
1306 { 0, 0, 0, 1306 { 0, 0, 0,
1307 (sy_call_t *)rump_enosys }, /* 81 = unrumped */ 1307 (sy_call_t *)rump_enosys }, /* 81 = unrumped */
1308 { 0, 0, 0, 1308 { 0, 0, 0,
1309 (sy_call_t *)rump_enosys }, /* 82 = unrumped */ 1309 (sy_call_t *)rump_enosys }, /* 82 = unrumped */
1310 { 0, 0, 0, 1310 { 0, 0, 0,
1311 (sy_call_t *)rump_enosys }, /* 83 = unrumped */ 1311 (sy_call_t *)rump_enosys }, /* 83 = unrumped */
1312 { 0, 0, 0, 1312 { 0, 0, 0,
1313 (sy_call_t *)rump_enosys }, /* 84 = unrumped */ 1313 (sy_call_t *)rump_enosys }, /* 84 = unrumped */
1314 { 0, 0, 0, 1314 { 0, 0, 0,
1315 (sy_call_t *)rump_enosys }, /* 85 = unrumped */ 1315 (sy_call_t *)rump_enosys }, /* 85 = unrumped */
1316 { 0, 0, 0, 1316 { 0, 0, 0,
1317 (sy_call_t *)rump_enosys }, /* 86 = unrumped */ 1317 (sy_call_t *)rump_enosys }, /* 86 = unrumped */
1318 { 0, 0, 0, 1318 { 0, 0, 0,
1319 (sy_call_t *)rump_enosys }, /* 87 = unrumped */ 1319 (sy_call_t *)rump_enosys }, /* 87 = unrumped */
1320 { 0, 0, 0, 1320 { 0, 0, 0,
1321 (sy_call_t *)rump_enosys }, /* 88 = unrumped */ 1321 (sy_call_t *)rump_enosys }, /* 88 = unrumped */
1322 { 0, 0, 0, 1322 { 0, 0, 0,
1323 (sy_call_t *)rump_enosys }, /* 89 = unrumped */ 1323 (sy_call_t *)rump_enosys }, /* 89 = unrumped */
1324 { 0, 0, 0, 1324 { 0, 0, 0,
1325 (sy_call_t *)rump_enosys }, /* 90 = unrumped */ 1325 (sy_call_t *)rump_enosys }, /* 90 = unrumped */
1326 { 0, 0, 0, 1326 { 0, 0, 0,
1327 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 1327 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */
1328 { 0, 0, 0, 1328 { 0, 0, 0,
1329 (sy_call_t *)rump_enosys }, /* 92 = unrumped */ 1329 (sy_call_t *)rump_enosys }, /* 92 = unrumped */
1330 { 0, 0, 0, 1330 { 0, 0, 0,
1331 (sy_call_t *)rump_enosys }, /* 93 = unrumped */ 1331 (sy_call_t *)rump_enosys }, /* 93 = unrumped */
1332 { 0, 0, 0, 1332 { 0, 0, 0,
1333 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 1333 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */
1334 { ns(struct sys_fsync_args), 0, 1334 { ns(struct sys_fsync_args), 0,
1335 (sy_call_t *)sys_fsync }, /* 95 = fsync */ 1335 (sy_call_t *)sys_fsync }, /* 95 = fsync */
1336 { 0, 0, 0, 1336 { 0, 0, 0,
1337 (sy_call_t *)rump_enosys }, /* 96 = unrumped */ 1337 (sy_call_t *)rump_enosys }, /* 96 = unrumped */
1338 { 0, 0, 0, 1338 { 0, 0, 0,
1339 (sy_call_t *)rump_enosys }, /* 97 = unrumped */ 1339 (sy_call_t *)rump_enosys }, /* 97 = unrumped */
1340 { ns(struct sys_connect_args), 0, 1340 { ns(struct sys_connect_args), 0,
1341 (sy_call_t *)sys_connect }, /* 98 = connect */ 1341 (sy_call_t *)sys_connect }, /* 98 = connect */
1342 { 0, 0, 0, 1342 { 0, 0, 0,
1343 (sy_call_t *)rump_enosys }, /* 99 = unrumped */ 1343 (sy_call_t *)rump_enosys }, /* 99 = unrumped */
1344 { 0, 0, 0, 1344 { 0, 0, 0,
1345 (sy_call_t *)rump_enosys }, /* 100 = unrumped */ 1345 (sy_call_t *)rump_enosys }, /* 100 = unrumped */
1346 { 0, 0, 0, 1346 { 0, 0, 0,
1347 (sy_call_t *)rump_enosys }, /* 101 = unrumped */ 1347 (sy_call_t *)rump_enosys }, /* 101 = unrumped */
1348 { 0, 0, 0, 1348 { 0, 0, 0,
1349 (sy_call_t *)rump_enosys }, /* 102 = unrumped */ 1349 (sy_call_t *)rump_enosys }, /* 102 = unrumped */
1350 { 0, 0, 0, 1350 { 0, 0, 0,
1351 (sy_call_t *)rump_enosys }, /* 103 = unrumped */ 1351 (sy_call_t *)rump_enosys }, /* 103 = unrumped */
1352 { ns(struct sys_bind_args), 0, 1352 { ns(struct sys_bind_args), 0,
1353 (sy_call_t *)sys_bind }, /* 104 = bind */ 1353 (sy_call_t *)sys_bind }, /* 104 = bind */
1354 { ns(struct sys_setsockopt_args), 0, 1354 { ns(struct sys_setsockopt_args), 0,
1355 (sy_call_t *)sys_setsockopt }, /* 105 = setsockopt */ 1355 (sy_call_t *)sys_setsockopt }, /* 105 = setsockopt */
1356 { ns(struct sys_listen_args), 0, 1356 { ns(struct sys_listen_args), 0,
1357 (sy_call_t *)sys_listen }, /* 106 = listen */ 1357 (sy_call_t *)sys_listen }, /* 106 = listen */
1358 { 0, 0, 0, 1358 { 0, 0, 0,
1359 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 1359 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */
1360 { 0, 0, 0, 1360 { 0, 0, 0,
1361 (sy_call_t *)rump_enosys }, /* 108 = unrumped */ 1361 (sy_call_t *)rump_enosys }, /* 108 = unrumped */
1362 { 0, 0, 0, 1362 { 0, 0, 0,
1363 (sy_call_t *)rump_enosys }, /* 109 = unrumped */ 1363 (sy_call_t *)rump_enosys }, /* 109 = unrumped */
1364 { 0, 0, 0, 1364 { 0, 0, 0,
1365 (sy_call_t *)rump_enosys }, /* 110 = unrumped */ 1365 (sy_call_t *)rump_enosys }, /* 110 = unrumped */
1366 { 0, 0, 0, 1366 { 0, 0, 0,
1367 (sy_call_t *)rump_enosys }, /* 111 = unrumped */ 1367 (sy_call_t *)rump_enosys }, /* 111 = unrumped */
1368 { 0, 0, 0, 1368 { 0, 0, 0,
1369 (sy_call_t *)rump_enosys }, /* 112 = unrumped */ 1369 (sy_call_t *)rump_enosys }, /* 112 = unrumped */
1370 { 0, 0, 0, 1370 { 0, 0, 0,
1371 (sy_call_t *)rump_enosys }, /* 113 = unrumped */ 1371 (sy_call_t *)rump_enosys }, /* 113 = unrumped */
1372 { 0, 0, 0, 1372 { 0, 0, 0,
1373 (sy_call_t *)rump_enosys }, /* 114 = unrumped */ 1373 (sy_call_t *)rump_enosys }, /* 114 = unrumped */
1374 { 0, 0, 0, 1374 { 0, 0, 0,
1375 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 1375 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */
1376 { 0, 0, 0, 1376 { 0, 0, 0,
1377 (sy_call_t *)rump_enosys }, /* 116 = unrumped */ 1377 (sy_call_t *)rump_enosys }, /* 116 = unrumped */
1378 { 0, 0, 0, 1378 { 0, 0, 0,
1379 (sy_call_t *)rump_enosys }, /* 117 = unrumped */ 1379 (sy_call_t *)rump_enosys }, /* 117 = unrumped */
1380 { ns(struct sys_getsockopt_args), 0, 1380 { ns(struct sys_getsockopt_args), 0,
1381 (sy_call_t *)sys_getsockopt }, /* 118 = getsockopt */ 1381 (sy_call_t *)sys_getsockopt }, /* 118 = getsockopt */
1382 { 0, 0, 0, 1382 { 0, 0, 0,
1383 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 1383 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */
1384 { 0, 0, 0, 1384 { 0, 0, 0,
1385 (sy_call_t *)rump_enosys }, /* 120 = unrumped */ 1385 (sy_call_t *)rump_enosys }, /* 120 = unrumped */
1386 { 0, 0, 0, 1386 { 0, 0, 0,
1387 (sy_call_t *)rump_enosys }, /* 121 = unrumped */ 1387 (sy_call_t *)rump_enosys }, /* 121 = unrumped */
1388 { 0, 0, 0, 1388 { 0, 0, 0,
1389 (sy_call_t *)rump_enosys }, /* 122 = unrumped */ 1389 (sy_call_t *)rump_enosys }, /* 122 = unrumped */
1390 { 0, 0, 0, 1390 { 0, 0, 0,
1391 (sy_call_t *)rump_enosys }, /* 123 = unrumped */ 1391 (sy_call_t *)rump_enosys }, /* 123 = unrumped */
1392 { 0, 0, 0, 1392 { 0, 0, 0,
1393 (sy_call_t *)rump_enosys }, /* 124 = unrumped */ 1393 (sy_call_t *)rump_enosys }, /* 124 = unrumped */
1394 { 0, 0, 0, 1394 { 0, 0, 0,
1395 (sy_call_t *)rump_enosys }, /* 125 = unrumped */ 1395 (sy_call_t *)rump_enosys }, /* 125 = unrumped */
1396 { 0, 0, 0, 1396 { 0, 0, 0,
1397 (sy_call_t *)rump_enosys }, /* 126 = unrumped */ 1397 (sy_call_t *)rump_enosys }, /* 126 = unrumped */
1398 { 0, 0, 0, 1398 { 0, 0, 0,
1399 (sy_call_t *)rump_enosys }, /* 127 = unrumped */ 1399 (sy_call_t *)rump_enosys }, /* 127 = unrumped */
1400 { ns(struct sys_rename_args), 0, 1400 { ns(struct sys_rename_args), 0,
1401 (sy_call_t *)sys_rename }, /* 128 = rename */ 1401 (sy_call_t *)sys_rename }, /* 128 = rename */
1402 { 0, 0, 0, 1402 { 0, 0, 0,
1403 (sy_call_t *)rump_enosys }, /* 129 = unrumped */ 1403 (sy_call_t *)rump_enosys }, /* 129 = unrumped */
1404 { 0, 0, 0, 1404 { 0, 0, 0,
1405 (sy_call_t *)rump_enosys }, /* 130 = unrumped */ 1405 (sy_call_t *)rump_enosys }, /* 130 = unrumped */
1406 { 0, 0, 0, 1406 { 0, 0, 0,
1407 (sy_call_t *)rump_enosys }, /* 131 = unrumped */ 1407 (sy_call_t *)rump_enosys }, /* 131 = unrumped */
1408 { ns(struct sys_mkfifo_args), 0, 1408 { ns(struct sys_mkfifo_args), 0,
1409 (sy_call_t *)sys_mkfifo }, /* 132 = mkfifo */ 1409 (sy_call_t *)sys_mkfifo }, /* 132 = mkfifo */
1410 { ns(struct sys_sendto_args), 0, 1410 { ns(struct sys_sendto_args), 0,
1411 (sy_call_t *)sys_sendto }, /* 133 = sendto */ 1411 (sy_call_t *)sys_sendto }, /* 133 = sendto */
1412 { ns(struct sys_shutdown_args), 0, 1412 { ns(struct sys_shutdown_args), 0,
1413 (sy_call_t *)sys_shutdown }, /* 134 = shutdown */ 1413 (sy_call_t *)sys_shutdown }, /* 134 = shutdown */
1414 { ns(struct sys_socketpair_args), 0, 1414 { ns(struct sys_socketpair_args), 0,
1415 (sy_call_t *)sys_socketpair }, /* 135 = socketpair */ 1415 (sy_call_t *)sys_socketpair }, /* 135 = socketpair */
1416 { ns(struct sys_mkdir_args), 0, 1416 { ns(struct sys_mkdir_args), 0,
1417 (sy_call_t *)sys_mkdir }, /* 136 = mkdir */ 1417 (sy_call_t *)sys_mkdir }, /* 136 = mkdir */
1418 { ns(struct sys_rmdir_args), 0, 1418 { ns(struct sys_rmdir_args), 0,
1419 (sy_call_t *)sys_rmdir }, /* 137 = rmdir */ 1419 (sy_call_t *)sys_rmdir }, /* 137 = rmdir */
1420 { 0, 0, 0, 1420 { 0, 0, 0,
1421 (sy_call_t *)rump_enosys }, /* 138 = unrumped */ 1421 (sy_call_t *)rump_enosys }, /* 138 = unrumped */
1422 { 0, 0, 0, 1422 { 0, 0, 0,
1423 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 1423 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */
1424 { 0, 0, 0, 1424 { 0, 0, 0,
1425 (sy_call_t *)rump_enosys }, /* 140 = unrumped */ 1425 (sy_call_t *)rump_enosys }, /* 140 = unrumped */
1426 { 0, 0, 0, 1426 { 0, 0, 0,
1427 (sy_call_t *)rump_enosys }, /* 141 = unrumped */ 1427 (sy_call_t *)rump_enosys }, /* 141 = unrumped */
1428 { 0, 0, 0, 1428 { 0, 0, 0,
1429 (sy_call_t *)rump_enosys }, /* 142 = unrumped */ 1429 (sy_call_t *)rump_enosys }, /* 142 = unrumped */
1430 { 0, 0, 0, 1430 { 0, 0, 0,
1431 (sy_call_t *)rump_enosys }, /* 143 = unrumped */ 1431 (sy_call_t *)rump_enosys }, /* 143 = unrumped */
1432 { 0, 0, 0, 1432 { 0, 0, 0,
1433 (sy_call_t *)rump_enosys }, /* 144 = unrumped */ 1433 (sy_call_t *)rump_enosys }, /* 144 = unrumped */
1434 { 0, 0, 0, 1434 { 0, 0, 0,
1435 (sy_call_t *)rump_enosys }, /* 145 = unrumped */ 1435 (sy_call_t *)rump_enosys }, /* 145 = unrumped */
1436 { 0, 0, 0, 1436 { 0, 0, 0,
1437 (sy_call_t *)rump_enosys }, /* 146 = unrumped */ 1437 (sy_call_t *)rump_enosys }, /* 146 = unrumped */
1438 { 0, 0, 0, 1438 { 0, 0, 0,
1439 (sy_call_t *)rump_enosys }, /* 147 = unrumped */ 1439 (sy_call_t *)rump_enosys }, /* 147 = unrumped */
1440 { 0, 0, 0, 1440 { 0, 0, 0,
1441 (sy_call_t *)rump_enosys }, /* 148 = unrumped */ 1441 (sy_call_t *)rump_enosys }, /* 148 = unrumped */
1442 { 0, 0, 0, 1442 { 0, 0, 0,
1443 (sy_call_t *)rump_enosys }, /* 149 = unrumped */ 1443 (sy_call_t *)rump_enosys }, /* 149 = unrumped */
1444 { 0, 0, 0, 1444 { 0, 0, 0,
1445 (sy_call_t *)rump_enosys }, /* 150 = unrumped */ 1445 (sy_call_t *)rump_enosys }, /* 150 = unrumped */
1446 { 0, 0, 0, 1446 { 0, 0, 0,
1447 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 1447 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */
1448 { 0, 0, 0, 1448 { 0, 0, 0,
1449 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 1449 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */
1450 { 0, 0, 0, 1450 { 0, 0, 0,
1451 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 1451 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */
1452 { 0, 0, 0, 1452 { 0, 0, 0,
1453 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 1453 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */
1454 { ns(struct sys_nfssvc_args), 0, 1454 { ns(struct sys_nfssvc_args), 0,
1455 (sy_call_t *)sys_nomodule }, /* 155 = nfssvc */ 1455 (sy_call_t *)sys_nomodule }, /* 155 = nfssvc */
1456 { 0, 0, 0, 1456 { 0, 0, 0,
1457 (sy_call_t *)rump_enosys }, /* 156 = unrumped */ 1457 (sy_call_t *)rump_enosys }, /* 156 = unrumped */
1458 { 0, 0, 0, 1458 { 0, 0, 0,
1459 (sy_call_t *)rump_enosys }, /* 157 = unrumped */ 1459 (sy_call_t *)rump_enosys }, /* 157 = unrumped */
1460 { 0, 0, 0, 1460 { 0, 0, 0,
1461 (sy_call_t *)rump_enosys }, /* 158 = unrumped */ 1461 (sy_call_t *)rump_enosys }, /* 158 = unrumped */
1462 { 0, 0, 0, 1462 { 0, 0, 0,
1463 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 1463 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */
1464 { 0, 0, 0, 1464 { 0, 0, 0,
1465 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 1465 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */
1466 { 0, 0, 0, 1466 { 0, 0, 0,
1467 (sy_call_t *)rump_enosys }, /* 161 = unrumped */ 1467 (sy_call_t *)rump_enosys }, /* 161 = unrumped */
1468 { 0, 0, 0, 1468 { 0, 0, 0,
1469 (sy_call_t *)rump_enosys }, /* 162 = unrumped */ 1469 (sy_call_t *)rump_enosys }, /* 162 = unrumped */
1470 { 0, 0, 0, 1470 { 0, 0, 0,
1471 (sy_call_t *)rump_enosys }, /* 163 = unrumped */ 1471 (sy_call_t *)rump_enosys }, /* 163 = unrumped */
1472 { 0, 0, 0, 1472 { 0, 0, 0,
1473 (sy_call_t *)rump_enosys }, /* 164 = unrumped */ 1473 (sy_call_t *)rump_enosys }, /* 164 = unrumped */
1474 { 0, 0, 0, 1474 { 0, 0, 0,
1475 (sy_call_t *)rump_enosys }, /* 165 = unrumped */ 1475 (sy_call_t *)rump_enosys }, /* 165 = unrumped */
1476 { 0, 0, 0, 1476 { 0, 0, 0,
1477 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 1477 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */
1478 { 0, 0, 0, 1478 { 0, 0, 0,
1479 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 1479 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */
1480 { 0, 0, 0, 1480 { 0, 0, 0,
1481 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 1481 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */
1482#if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 1482#if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
1483 { 0, 0, 0, 1483 { 0, 0, 0,
1484 (sy_call_t *)rump_enosys }, /* 169 = unrumped */ 1484 (sy_call_t *)rump_enosys }, /* 169 = unrumped */
1485#else 1485#else
1486 { 0, 0, 0, 1486 { 0, 0, 0,
1487 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 1487 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */
1488#endif 1488#endif
1489#if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 1489#if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64)
1490 { 0, 0, 0, 1490 { 0, 0, 0,
1491 (sy_call_t *)rump_enosys }, /* 170 = unrumped */ 1491 (sy_call_t *)rump_enosys }, /* 170 = unrumped */
1492#else 1492#else
1493 { 0, 0, 0, 1493 { 0, 0, 0,
1494 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 1494 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */
1495#endif 1495#endif
1496#if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 1496#if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
1497 { 0, 0, 0, 1497 { 0, 0, 0,
1498 (sy_call_t *)rump_enosys }, /* 171 = unrumped */ 1498 (sy_call_t *)rump_enosys }, /* 171 = unrumped */
1499#else 1499#else
1500 { 0, 0, 0, 1500 { 0, 0, 0,
1501 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 1501 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */
1502#endif 1502#endif
1503 { 0, 0, 0, 1503 { 0, 0, 0,
1504 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 1504 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */
1505 { ns(struct sys_pread_args), 0, 1505 { ns(struct sys_pread_args), 0,
1506 (sy_call_t *)sys_pread }, /* 173 = pread */ 1506 (sy_call_t *)sys_pread }, /* 173 = pread */
1507 { ns(struct sys_pwrite_args), 0, 1507 { ns(struct sys_pwrite_args), 0,
1508 (sy_call_t *)sys_pwrite }, /* 174 = pwrite */ 1508 (sy_call_t *)sys_pwrite }, /* 174 = pwrite */
1509 { 0, 0, 0, 1509 { 0, 0, 0,
1510 (sy_call_t *)rump_enosys }, /* 175 = unrumped */ 1510 (sy_call_t *)rump_enosys }, /* 175 = unrumped */
1511#if defined(NTP) || !defined(_KERNEL_OPT) 1511#if defined(NTP) || !defined(_KERNEL_OPT)
1512 { 0, 0, 0, 1512 { 0, 0, 0,
1513 (sy_call_t *)rump_enosys }, /* 176 = unrumped */ 1513 (sy_call_t *)rump_enosys }, /* 176 = unrumped */
1514#else 1514#else
1515 { 0, 0, 0, 1515 { 0, 0, 0,
1516 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 1516 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */
1517#endif 1517#endif
1518 { 0, 0, 0, 1518 { 0, 0, 0,
1519 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 1519 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */
1520 { 0, 0, 0, 1520 { 0, 0, 0,
1521 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 1521 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */
1522 { 0, 0, 0, 1522 { 0, 0, 0,
1523 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 1523 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */
1524 { 0, 0, 0, 1524 { 0, 0, 0,
1525 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 1525 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */
1526 { 0, 0, 0, 1526 { 0, 0, 0,
1527 (sy_call_t *)rump_enosys }, /* 181 = unrumped */ 1527 (sy_call_t *)rump_enosys }, /* 181 = unrumped */
1528 { 0, 0, 0, 1528 { 0, 0, 0,
1529 (sy_call_t *)rump_enosys }, /* 182 = unrumped */ 1529 (sy_call_t *)rump_enosys }, /* 182 = unrumped */
1530 { 0, 0, 0, 1530 { 0, 0, 0,
1531 (sy_call_t *)rump_enosys }, /* 183 = unrumped */ 1531 (sy_call_t *)rump_enosys }, /* 183 = unrumped */
1532#if defined(LFS) || !defined(_KERNEL) 1532#if defined(LFS) || !defined(_KERNEL)
1533 { 0, 0, 0, 1533 { 0, 0, 0,
1534 (sy_call_t *)rump_enosys }, /* 184 = unrumped */ 1534 (sy_call_t *)rump_enosys }, /* 184 = unrumped */
1535 { 0, 0, 0, 1535 { 0, 0, 0,
1536 (sy_call_t *)rump_enosys }, /* 185 = unrumped */ 1536 (sy_call_t *)rump_enosys }, /* 185 = unrumped */
1537 { 0, 0, 0, 1537 { 0, 0, 0,
1538 (sy_call_t *)rump_enosys }, /* 186 = unrumped */ 1538 (sy_call_t *)rump_enosys }, /* 186 = unrumped */
1539 { 0, 0, 0, 1539 { 0, 0, 0,
1540 (sy_call_t *)rump_enosys }, /* 187 = unrumped */ 1540 (sy_call_t *)rump_enosys }, /* 187 = unrumped */
1541#else 1541#else
1542 { 0, 0, 0, 1542 { 0, 0, 0,
1543 (sy_call_t *)rump_enosys }, /* 184 = excluded lfs_bmapv */ 1543 (sy_call_t *)rump_enosys }, /* 184 = excluded lfs_bmapv */
1544 { 0, 0, 0, 1544 { 0, 0, 0,
1545 (sy_call_t *)rump_enosys }, /* 185 = excluded lfs_markv */ 1545 (sy_call_t *)rump_enosys }, /* 185 = excluded lfs_markv */
1546 { 0, 0, 0, 1546 { 0, 0, 0,
1547 (sy_call_t *)rump_enosys }, /* 186 = excluded lfs_segclean */ 1547 (sy_call_t *)rump_enosys }, /* 186 = excluded lfs_segclean */
1548 { 0, 0, 0, 1548 { 0, 0, 0,
1549 (sy_call_t *)rump_enosys }, /* 187 = excluded lfs_segwait */ 1549 (sy_call_t *)rump_enosys }, /* 187 = excluded lfs_segwait */
1550#endif 1550#endif
1551 { 0, 0, 0, 1551 { 0, 0, 0,
1552 (sy_call_t *)rump_enosys }, /* 188 = unrumped */ 1552 (sy_call_t *)rump_enosys }, /* 188 = unrumped */
1553 { 0, 0, 0, 1553 { 0, 0, 0,
1554 (sy_call_t *)rump_enosys }, /* 189 = unrumped */ 1554 (sy_call_t *)rump_enosys }, /* 189 = unrumped */
1555 { 0, 0, 0, 1555 { 0, 0, 0,
1556 (sy_call_t *)rump_enosys }, /* 190 = unrumped */ 1556 (sy_call_t *)rump_enosys }, /* 190 = unrumped */
1557 { 0, 0, 0, 1557 { 0, 0, 0,
1558 (sy_call_t *)rump_enosys }, /* 191 = unrumped */ 1558 (sy_call_t *)rump_enosys }, /* 191 = unrumped */
1559 { 0, 0, 0, 1559 { 0, 0, 0,
1560 (sy_call_t *)rump_enosys }, /* 192 = unrumped */ 1560 (sy_call_t *)rump_enosys }, /* 192 = unrumped */
1561 { 0, 0, 0, 1561 { 0, 0, 0,
1562 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 1562 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */
1563 { 0, 0, 0, 1563 { 0, 0, 0,
1564 (sy_call_t *)rump_enosys }, /* 194 = unrumped */ 1564 (sy_call_t *)rump_enosys }, /* 194 = unrumped */
1565 { 0, 0, 0, 1565 { 0, 0, 0,
1566 (sy_call_t *)rump_enosys }, /* 195 = unrumped */ 1566 (sy_call_t *)rump_enosys }, /* 195 = unrumped */
1567 { 0, 0, 0, 1567 { 0, 0, 0,
1568 (sy_call_t *)rump_enosys }, /* 196 = unrumped */ 1568 (sy_call_t *)rump_enosys }, /* 196 = unrumped */
1569 { 0, 0, 0, 1569 { 0, 0, 0,
1570 (sy_call_t *)rump_enosys }, /* 197 = unrumped */ 1570 (sy_call_t *)rump_enosys }, /* 197 = unrumped */
1571 { 0, 0, 0, 1571 { 0, 0, 0,
1572 (sy_call_t *)rump_enosys }, /* 198 = unrumped */ 1572 (sy_call_t *)rump_enosys }, /* 198 = unrumped */
1573 { 0, 0, 0, 1573 { 0, 0, 0,
1574 (sy_call_t *)rump_enosys }, /* 199 = unrumped */ 1574 (sy_call_t *)rump_enosys }, /* 199 = unrumped */
1575 { ns(struct sys_truncate_args), 0, 1575 { ns(struct sys_truncate_args), 0,
1576 (sy_call_t *)sys_truncate }, /* 200 = truncate */ 1576 (sy_call_t *)sys_truncate }, /* 200 = truncate */
1577 { 0, 0, 0, 1577 { 0, 0, 0,
1578 (sy_call_t *)rump_enosys }, /* 201 = unrumped */ 1578 (sy_call_t *)rump_enosys }, /* 201 = unrumped */
1579 { ns(struct sys___sysctl_args), 0, 1579 { ns(struct sys___sysctl_args), 0,
1580 (sy_call_t *)sys___sysctl }, /* 202 = __sysctl */ 1580 (sy_call_t *)sys___sysctl }, /* 202 = __sysctl */
1581 { 0, 0, 0, 1581 { 0, 0, 0,
1582 (sy_call_t *)rump_enosys }, /* 203 = unrumped */ 1582 (sy_call_t *)rump_enosys }, /* 203 = unrumped */
1583 { 0, 0, 0, 1583 { 0, 0, 0,
1584 (sy_call_t *)rump_enosys }, /* 204 = unrumped */ 1584 (sy_call_t *)rump_enosys }, /* 204 = unrumped */
1585 { 0, 0, 0, 1585 { 0, 0, 0,
1586 (sy_call_t *)rump_enosys }, /* 205 = unrumped */ 1586 (sy_call_t *)rump_enosys }, /* 205 = unrumped */
1587 { 0, 0, 0, 1587 { 0, 0, 0,
1588 (sy_call_t *)rump_enosys }, /* 206 = unrumped */ 1588 (sy_call_t *)rump_enosys }, /* 206 = unrumped */
1589 { 0, 0, 0, 1589 { 0, 0, 0,
1590 (sy_call_t *)rump_enosys }, /* 207 = unrumped */ 1590 (sy_call_t *)rump_enosys }, /* 207 = unrumped */
1591 { 0, 0, 0, 1591 { 0, 0, 0,
1592 (sy_call_t *)rump_enosys }, /* 208 = unrumped */ 1592 (sy_call_t *)rump_enosys }, /* 208 = unrumped */
1593 { 0, 0, 0, 1593 { 0, 0, 0,
1594 (sy_call_t *)rump_enosys }, /* 209 = unrumped */ 1594 (sy_call_t *)rump_enosys }, /* 209 = unrumped */
1595 { 0, 0, 0, 1595 { 0, 0, 0,
1596 (sy_call_t *)rump_enosys }, /* 210 = unimplemented */ 1596 (sy_call_t *)rump_enosys }, /* 210 = unimplemented */
1597 { 0, 0, 0, 1597 { 0, 0, 0,
1598 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 1598 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */
1599 { 0, 0, 0, 1599 { 0, 0, 0,
1600 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 1600 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */
1601 { 0, 0, 0, 1601 { 0, 0, 0,
1602 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 1602 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */
1603 { 0, 0, 0, 1603 { 0, 0, 0,
1604 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 1604 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */
1605 { 0, 0, 0, 1605 { 0, 0, 0,
1606 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 1606 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */
1607 { 0, 0, 0, 1607 { 0, 0, 0,
1608 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 1608 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */
1609 { 0, 0, 0, 1609 { 0, 0, 0,
1610 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 1610 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */
1611 { 0, 0, 0, 1611 { 0, 0, 0,
1612 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 1612 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */
1613 { 0, 0, 0, 1613 { 0, 0, 0,
1614 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 1614 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */
1615#if defined(SYSVSEM) || !defined(_KERNEL_OPT) 1615#if defined(SYSVSEM) || !defined(_KERNEL_OPT)
1616 { 0, 0, 0, 1616 { 0, 0, 0,
1617 (sy_call_t *)rump_enosys }, /* 220 = unrumped */ 1617 (sy_call_t *)rump_enosys }, /* 220 = unrumped */
1618 { 0, 0, 0, 1618 { 0, 0, 0,
1619 (sy_call_t *)rump_enosys }, /* 221 = unrumped */ 1619 (sy_call_t *)rump_enosys }, /* 221 = unrumped */
1620 { 0, 0, 0, 1620 { 0, 0, 0,
1621 (sy_call_t *)rump_enosys }, /* 222 = unrumped */ 1621 (sy_call_t *)rump_enosys }, /* 222 = unrumped */
1622 { 0, 0, 0, 1622 { 0, 0, 0,
1623 (sy_call_t *)rump_enosys }, /* 223 = unrumped */ 1623 (sy_call_t *)rump_enosys }, /* 223 = unrumped */
1624#else 1624#else
1625 { 0, 0, 0, 1625 { 0, 0, 0,
1626 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 1626 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */
1627 { 0, 0, 0, 1627 { 0, 0, 0,
1628 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 1628 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */
1629 { 0, 0, 0, 1629 { 0, 0, 0,
1630 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 1630 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */
1631 { 0, 0, 0, 1631 { 0, 0, 0,
1632 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 1632 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */
1633#endif 1633#endif
1634#if defined(SYSVMSG) || !defined(_KERNEL_OPT) 1634#if defined(SYSVMSG) || !defined(_KERNEL_OPT)
1635 { 0, 0, 0, 1635 { 0, 0, 0,
1636 (sy_call_t *)rump_enosys }, /* 224 = unrumped */ 1636 (sy_call_t *)rump_enosys }, /* 224 = unrumped */
1637 { 0, 0, 0, 1637 { 0, 0, 0,
1638 (sy_call_t *)rump_enosys }, /* 225 = unrumped */ 1638 (sy_call_t *)rump_enosys }, /* 225 = unrumped */
1639 { 0, 0, 0, 1639 { 0, 0, 0,
1640 (sy_call_t *)rump_enosys }, /* 226 = unrumped */ 1640 (sy_call_t *)rump_enosys }, /* 226 = unrumped */
1641 { 0, 0, 0, 1641 { 0, 0, 0,
1642 (sy_call_t *)rump_enosys }, /* 227 = unrumped */ 1642 (sy_call_t *)rump_enosys }, /* 227 = unrumped */
1643#else 1643#else
1644 { 0, 0, 0, 1644 { 0, 0, 0,
1645 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 1645 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */
1646 { 0, 0, 0, 1646 { 0, 0, 0,
1647 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 1647 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */
1648 { 0, 0, 0, 1648 { 0, 0, 0,
1649 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 1649 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */
1650 { 0, 0, 0, 1650 { 0, 0, 0,
1651 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 1651 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */
1652#endif 1652#endif
1653#if defined(SYSVSHM) || !defined(_KERNEL_OPT) 1653#if defined(SYSVSHM) || !defined(_KERNEL_OPT)
1654 { 0, 0, 0, 1654 { 0, 0, 0,
1655 (sy_call_t *)rump_enosys }, /* 228 = unrumped */ 1655 (sy_call_t *)rump_enosys }, /* 228 = unrumped */
1656 { 0, 0, 0, 1656 { 0, 0, 0,
1657 (sy_call_t *)rump_enosys }, /* 229 = unrumped */ 1657 (sy_call_t *)rump_enosys }, /* 229 = unrumped */
1658 { 0, 0, 0, 1658 { 0, 0, 0,
1659 (sy_call_t *)rump_enosys }, /* 230 = unrumped */ 1659 (sy_call_t *)rump_enosys }, /* 230 = unrumped */
1660 { 0, 0, 0, 1660 { 0, 0, 0,
1661 (sy_call_t *)rump_enosys }, /* 231 = unrumped */ 1661 (sy_call_t *)rump_enosys }, /* 231 = unrumped */
1662#else 1662#else
1663 { 0, 0, 0, 1663 { 0, 0, 0,
1664 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 1664 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */
1665 { 0, 0, 0, 1665 { 0, 0, 0,
1666 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 1666 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */
1667 { 0, 0, 0, 1667 { 0, 0, 0,
1668 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 1668 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */
1669 { 0, 0, 0, 1669 { 0, 0, 0,
1670 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 1670 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */
1671#endif 1671#endif
1672 { 0, 0, 0, 1672 { 0, 0, 0,
1673 (sy_call_t *)rump_enosys }, /* 232 = unrumped */ 1673 (sy_call_t *)rump_enosys }, /* 232 = unrumped */
1674 { 0, 0, 0, 1674 { 0, 0, 0,
1675 (sy_call_t *)rump_enosys }, /* 233 = unrumped */ 1675 (sy_call_t *)rump_enosys }, /* 233 = unrumped */
1676 { 0, 0, 0, 1676 { 0, 0, 0,
1677 (sy_call_t *)rump_enosys }, /* 234 = unrumped */ 1677 (sy_call_t *)rump_enosys }, /* 234 = unrumped */
1678 { 0, 0, 0, 1678 { 0, 0, 0,
1679 (sy_call_t *)rump_enosys }, /* 235 = unrumped */ 1679 (sy_call_t *)rump_enosys }, /* 235 = unrumped */
1680 { 0, 0, 0, 1680 { 0, 0, 0,
1681 (sy_call_t *)rump_enosys }, /* 236 = unrumped */ 1681 (sy_call_t *)rump_enosys }, /* 236 = unrumped */
1682 { 0, 0, 0, 1682 { 0, 0, 0,
1683 (sy_call_t *)rump_enosys }, /* 237 = unrumped */ 1683 (sy_call_t *)rump_enosys }, /* 237 = unrumped */
1684 { 0, 0, 0, 1684 { 0, 0, 0,
1685 (sy_call_t *)rump_enosys }, /* 238 = unrumped */ 1685 (sy_call_t *)rump_enosys }, /* 238 = unrumped */
1686 { 0, 0, 0, 1686 { 0, 0, 0,
1687 (sy_call_t *)rump_enosys }, /* 239 = unrumped */ 1687 (sy_call_t *)rump_enosys }, /* 239 = unrumped */
1688 { 0, 0, 0, 1688 { 0, 0, 0,
1689 (sy_call_t *)rump_enosys }, /* 240 = unrumped */ 1689 (sy_call_t *)rump_enosys }, /* 240 = unrumped */
1690 { 0, 0, 0, 1690 { 0, 0, 0,
1691 (sy_call_t *)rump_enosys }, /* 241 = unrumped */ 1691 (sy_call_t *)rump_enosys }, /* 241 = unrumped */
1692 { 0, 0, 0, 1692 { 0, 0, 0,
1693 (sy_call_t *)rump_enosys }, /* 242 = unrumped */ 1693 (sy_call_t *)rump_enosys }, /* 242 = unrumped */
1694 { 0, 0, 0, 1694 { 0, 0, 0,
1695 (sy_call_t *)rump_enosys }, /* 243 = unrumped */ 1695 (sy_call_t *)rump_enosys }, /* 243 = unrumped */
1696 { 0, 0, 0, 1696 { 0, 0, 0,
1697 (sy_call_t *)rump_enosys }, /* 244 = unrumped */ 1697 (sy_call_t *)rump_enosys }, /* 244 = unrumped */
1698 { 0, 0, 0, 1698 { 0, 0, 0,
1699 (sy_call_t *)rump_enosys }, /* 245 = unimplemented sys_sigqueue */ 1699 (sy_call_t *)rump_enosys }, /* 245 = unimplemented sys_sigqueue */
1700 { 0, 0, 0, 1700 { 0, 0, 0,
1701 (sy_call_t *)rump_enosys }, /* 246 = unrumped */ 1701 (sy_call_t *)rump_enosys }, /* 246 = unrumped */
1702 { 0, 0, 0, 1702 { 0, 0, 0,
1703 (sy_call_t *)rump_enosys }, /* 247 = unrumped */ 1703 (sy_call_t *)rump_enosys }, /* 247 = unrumped */
1704 { 0, 0, 0, 1704 { 0, 0, 0,
1705 (sy_call_t *)rump_enosys }, /* 248 = unrumped */ 1705 (sy_call_t *)rump_enosys }, /* 248 = unrumped */
1706 { 0, 0, 0, 1706 { 0, 0, 0,
1707 (sy_call_t *)rump_enosys }, /* 249 = unrumped */ 1707 (sy_call_t *)rump_enosys }, /* 249 = unrumped */
1708 { 0, 0, 0, 1708 { 0, 0, 0,
1709 (sy_call_t *)rump_enosys }, /* 250 = unrumped */ 1709 (sy_call_t *)rump_enosys }, /* 250 = unrumped */
1710 { 0, 0, 0, 1710 { 0, 0, 0,
1711 (sy_call_t *)rump_enosys }, /* 251 = unrumped */ 1711 (sy_call_t *)rump_enosys }, /* 251 = unrumped */
1712 { 0, 0, 0, 1712 { 0, 0, 0,
1713 (sy_call_t *)rump_enosys }, /* 252 = unrumped */ 1713 (sy_call_t *)rump_enosys }, /* 252 = unrumped */
1714 { 0, 0, 0, 1714 { 0, 0, 0,
1715 (sy_call_t *)rump_enosys }, /* 253 = unrumped */ 1715 (sy_call_t *)rump_enosys }, /* 253 = unrumped */
1716 { 0, 0, 0, 1716 { 0, 0, 0,
1717 (sy_call_t *)rump_enosys }, /* 254 = unrumped */ 1717 (sy_call_t *)rump_enosys }, /* 254 = unrumped */
1718 { 0, 0, 0, 1718 { 0, 0, 0,
1719 (sy_call_t *)rump_enosys }, /* 255 = unrumped */ 1719 (sy_call_t *)rump_enosys }, /* 255 = unrumped */
1720 { 0, 0, 0, 1720 { 0, 0, 0,
1721 (sy_call_t *)rump_enosys }, /* 256 = unimplemented sys__ksem_timedwait */ 1721 (sy_call_t *)rump_enosys }, /* 256 = unimplemented sys__ksem_timedwait */
1722 { 0, 0, 0, 1722 { 0, 0, 0,
1723 (sy_call_t *)rump_enosys }, /* 257 = unrumped */ 1723 (sy_call_t *)rump_enosys }, /* 257 = unrumped */
1724 { 0, 0, 0, 1724 { 0, 0, 0,
1725 (sy_call_t *)rump_enosys }, /* 258 = unrumped */ 1725 (sy_call_t *)rump_enosys }, /* 258 = unrumped */
1726 { 0, 0, 0, 1726 { 0, 0, 0,
1727 (sy_call_t *)rump_enosys }, /* 259 = unrumped */ 1727 (sy_call_t *)rump_enosys }, /* 259 = unrumped */
1728 { 0, 0, 0, 1728 { 0, 0, 0,
1729 (sy_call_t *)rump_enosys }, /* 260 = unrumped */ 1729 (sy_call_t *)rump_enosys }, /* 260 = unrumped */
1730 { 0, 0, 0, 1730 { 0, 0, 0,
1731 (sy_call_t *)rump_enosys }, /* 261 = unrumped */ 1731 (sy_call_t *)rump_enosys }, /* 261 = unrumped */
1732 { 0, 0, 0, 1732 { 0, 0, 0,
1733 (sy_call_t *)rump_enosys }, /* 262 = unrumped */ 1733 (sy_call_t *)rump_enosys }, /* 262 = unrumped */
1734 { 0, 0, 0, 1734 { 0, 0, 0,
1735 (sy_call_t *)rump_enosys }, /* 263 = unrumped */ 1735 (sy_call_t *)rump_enosys }, /* 263 = unrumped */
1736 { 0, 0, 0, 1736 { 0, 0, 0,
1737 (sy_call_t *)rump_enosys }, /* 264 = unrumped */ 1737 (sy_call_t *)rump_enosys }, /* 264 = unrumped */
1738 { 0, 0, 0, 1738 { 0, 0, 0,
1739 (sy_call_t *)rump_enosys }, /* 265 = unrumped */ 1739 (sy_call_t *)rump_enosys }, /* 265 = unrumped */
1740 { 0, 0, 0, 1740 { 0, 0, 0,
1741 (sy_call_t *)rump_enosys }, /* 266 = unrumped */ 1741 (sy_call_t *)rump_enosys }, /* 266 = unrumped */
1742 { 0, 0, 0, 1742 { 0, 0, 0,
1743 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 1743 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */
1744 { 0, 0, 0, 1744 { 0, 0, 0,
1745 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 1745 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */
1746 { 0, 0, 0, 1746 { 0, 0, 0,
1747 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 1747 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */
1748 { 0, 0, 0, 1748 { 0, 0, 0,
1749 (sy_call_t *)rump_enosys }, /* 270 = unrumped */ 1749 (sy_call_t *)rump_enosys }, /* 270 = unrumped */
1750 { 0, 0, 0, 1750 { 0, 0, 0,
1751 (sy_call_t *)rump_enosys }, /* 271 = unrumped */ 1751 (sy_call_t *)rump_enosys }, /* 271 = unrumped */
1752 { 0, 0, 0, 1752 { 0, 0, 0,
1753 (sy_call_t *)rump_enosys }, /* 272 = unrumped */ 1753 (sy_call_t *)rump_enosys }, /* 272 = unrumped */
1754 { 0, 0, 0, 1754 { 0, 0, 0,
1755 (sy_call_t *)rump_enosys }, /* 273 = unrumped */ 1755 (sy_call_t *)rump_enosys }, /* 273 = unrumped */
1756 { ns(struct sys_lchmod_args), 0, 1756 { ns(struct sys_lchmod_args), 0,
1757 (sy_call_t *)sys_lchmod }, /* 274 = lchmod */ 1757 (sy_call_t *)sys_lchmod }, /* 274 = lchmod */
1758 { ns(struct sys_lchown_args), 0, 1758 { ns(struct sys_lchown_args), 0,
1759 (sy_call_t *)sys_lchown }, /* 275 = lchown */ 1759 (sy_call_t *)sys_lchown }, /* 275 = lchown */
1760 { 0, 0, 0, 1760 { 0, 0, 0,
1761 (sy_call_t *)rump_enosys }, /* 276 = unrumped */ 1761 (sy_call_t *)rump_enosys }, /* 276 = unrumped */
1762 { 0, 0, 0, 1762 { 0, 0, 0,
1763 (sy_call_t *)rump_enosys }, /* 277 = unrumped */ 1763 (sy_call_t *)rump_enosys }, /* 277 = unrumped */
1764 { 0, 0, 0, 1764 { 0, 0, 0,
1765 (sy_call_t *)rump_enosys }, /* 278 = unrumped */ 1765 (sy_call_t *)rump_enosys }, /* 278 = unrumped */
1766 { 0, 0, 0, 1766 { 0, 0, 0,
1767 (sy_call_t *)rump_enosys }, /* 279 = unrumped */ 1767 (sy_call_t *)rump_enosys }, /* 279 = unrumped */
1768 { 0, 0, 0, 1768 { 0, 0, 0,
1769 (sy_call_t *)rump_enosys }, /* 280 = unrumped */ 1769 (sy_call_t *)rump_enosys }, /* 280 = unrumped */
1770 { 0, 0, 0, 1770 { 0, 0, 0,
1771 (sy_call_t *)rump_enosys }, /* 281 = unrumped */ 1771 (sy_call_t *)rump_enosys }, /* 281 = unrumped */
1772 { 0, 0, 0, 1772 { 0, 0, 0,
1773 (sy_call_t *)rump_enosys }, /* 282 = unrumped */ 1773 (sy_call_t *)rump_enosys }, /* 282 = unrumped */
1774 { 0, 0, 0, 1774 { 0, 0, 0,
1775 (sy_call_t *)rump_enosys }, /* 283 = unrumped */ 1775 (sy_call_t *)rump_enosys }, /* 283 = unrumped */
1776 { 0, 0, 0, 1776 { 0, 0, 0,
1777 (sy_call_t *)rump_enosys }, /* 284 = unrumped */ 1777 (sy_call_t *)rump_enosys }, /* 284 = unrumped */
1778 { 0, 0, 0, 1778 { 0, 0, 0,
1779 (sy_call_t *)rump_enosys }, /* 285 = unrumped */ 1779 (sy_call_t *)rump_enosys }, /* 285 = unrumped */
1780 { 0, 0, 0, 1780 { 0, 0, 0,
1781 (sy_call_t *)rump_enosys }, /* 286 = unrumped */ 1781 (sy_call_t *)rump_enosys }, /* 286 = unrumped */
1782 { 0, 0, 0, 1782 { 0, 0, 0,
1783 (sy_call_t *)rump_enosys }, /* 287 = unrumped */ 1783 (sy_call_t *)rump_enosys }, /* 287 = unrumped */
1784 { 0, 0, 0, 1784 { 0, 0, 0,
1785 (sy_call_t *)rump_enosys }, /* 288 = unrumped */ 1785 (sy_call_t *)rump_enosys }, /* 288 = unrumped */
1786 { 0, 0, 0, 1786 { 0, 0, 0,
1787 (sy_call_t *)rump_enosys }, /* 289 = unrumped */ 1787 (sy_call_t *)rump_enosys }, /* 289 = unrumped */
1788 { 0, 0, 0, 1788 { 0, 0, 0,
1789 (sy_call_t *)rump_enosys }, /* 290 = unrumped */ 1789 (sy_call_t *)rump_enosys }, /* 290 = unrumped */
1790 { 0, 0, 0, 1790 { 0, 0, 0,
1791 (sy_call_t *)rump_enosys }, /* 291 = unrumped */ 1791 (sy_call_t *)rump_enosys }, /* 291 = unrumped */
1792 { 0, 0, 0, 1792 { 0, 0, 0,
1793 (sy_call_t *)rump_enosys }, /* 292 = unrumped */ 1793 (sy_call_t *)rump_enosys }, /* 292 = unrumped */
1794 { 0, 0, 0, 1794 { 0, 0, 0,
1795 (sy_call_t *)rump_enosys }, /* 293 = unrumped */ 1795 (sy_call_t *)rump_enosys }, /* 293 = unrumped */
1796 { 0, 0, 0, 1796 { 0, 0, 0,
1797 (sy_call_t *)rump_enosys }, /* 294 = unrumped */ 1797 (sy_call_t *)rump_enosys }, /* 294 = unrumped */
1798 { 0, 0, 0, 1798 { 0, 0, 0,
1799 (sy_call_t *)rump_enosys }, /* 295 = unrumped */ 1799 (sy_call_t *)rump_enosys }, /* 295 = unrumped */
1800 { 0, 0, 0, 1800 { 0, 0, 0,
1801 (sy_call_t *)rump_enosys }, /* 296 = unrumped */ 1801 (sy_call_t *)rump_enosys }, /* 296 = unrumped */
1802 { 0, 0, 0, 1802 { 0, 0, 0,
1803 (sy_call_t *)rump_enosys }, /* 297 = unrumped */ 1803 (sy_call_t *)rump_enosys }, /* 297 = unrumped */
1804 { 0, 0, 0, 1804 { 0, 0, 0,
1805 (sy_call_t *)rump_enosys }, /* 298 = unrumped */ 1805 (sy_call_t *)rump_enosys }, /* 298 = unrumped */
1806 { 0, 0, 0, 1806 { 0, 0, 0,
1807 (sy_call_t *)rump_enosys }, /* 299 = unrumped */ 1807 (sy_call_t *)rump_enosys }, /* 299 = unrumped */
1808 { 0, 0, 0, 1808 { 0, 0, 0,
1809 (sy_call_t *)rump_enosys }, /* 300 = unrumped */ 1809 (sy_call_t *)rump_enosys }, /* 300 = unrumped */
1810#if defined(SYSVSEM) || !defined(_KERNEL_OPT) 1810#if defined(SYSVSEM) || !defined(_KERNEL_OPT)
1811 { 0, 0, 0, 1811 { 0, 0, 0,
1812 (sy_call_t *)rump_enosys }, /* 301 = unrumped */ 1812 (sy_call_t *)rump_enosys }, /* 301 = unrumped */
1813#else 1813#else
1814 { 0, 0, 0, 1814 { 0, 0, 0,
1815 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 1815 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */
1816#endif 1816#endif
1817#if defined(SYSVMSG) || !defined(_KERNEL_OPT) 1817#if defined(SYSVMSG) || !defined(_KERNEL_OPT)
1818 { 0, 0, 0, 1818 { 0, 0, 0,
1819 (sy_call_t *)rump_enosys }, /* 302 = unrumped */ 1819 (sy_call_t *)rump_enosys }, /* 302 = unrumped */
1820#else 1820#else
1821 { 0, 0, 0, 1821 { 0, 0, 0,
1822 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 1822 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */
1823#endif 1823#endif
1824#if defined(SYSVSHM) || !defined(_KERNEL_OPT) 1824#if defined(SYSVSHM) || !defined(_KERNEL_OPT)
1825 { 0, 0, 0, 1825 { 0, 0, 0,
1826 (sy_call_t *)rump_enosys }, /* 303 = unrumped */ 1826 (sy_call_t *)rump_enosys }, /* 303 = unrumped */
1827#else 1827#else
1828 { 0, 0, 0, 1828 { 0, 0, 0,
1829 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 1829 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */
1830#endif 1830#endif
1831 { ns(struct sys_lchflags_args), 0, 1831 { ns(struct sys_lchflags_args), 0,
1832 (sy_call_t *)sys_lchflags }, /* 304 = lchflags */ 1832 (sy_call_t *)sys_lchflags }, /* 304 = lchflags */
1833 { 0, 0, 0, 1833 { 0, 0, 0,
1834 (sy_call_t *)rump_enosys }, /* 305 = unrumped */ 1834 (sy_call_t *)rump_enosys }, /* 305 = unrumped */
1835 { 0, 0, 0, 1835 { 0, 0, 0,
1836 (sy_call_t *)rump_enosys }, /* 306 = unrumped */ 1836 (sy_call_t *)rump_enosys }, /* 306 = unrumped */
1837 { 0, 0, 0, 1837 { 0, 0, 0,
1838 (sy_call_t *)rump_enosys }, /* 307 = unrumped */ 1838 (sy_call_t *)rump_enosys }, /* 307 = unrumped */
1839 { 0, 0, 0, 1839 { 0, 0, 0,
1840 (sy_call_t *)rump_enosys }, /* 308 = unrumped */ 1840 (sy_call_t *)rump_enosys }, /* 308 = unrumped */
1841 { 0, 0, 0, 1841 { 0, 0, 0,
1842 (sy_call_t *)rump_enosys }, /* 309 = unrumped */ 1842 (sy_call_t *)rump_enosys }, /* 309 = unrumped */
1843 { 0, 0, 0, 1843 { 0, 0, 0,
1844 (sy_call_t *)rump_enosys }, /* 310 = unrumped */ 1844 (sy_call_t *)rump_enosys }, /* 310 = unrumped */
1845 { 0, 0, 0, 1845 { 0, 0, 0,
1846 (sy_call_t *)rump_enosys }, /* 311 = unrumped */ 1846 (sy_call_t *)rump_enosys }, /* 311 = unrumped */
1847 { 0, 0, 0, 1847 { 0, 0, 0,
1848 (sy_call_t *)rump_enosys }, /* 312 = unrumped */ 1848 (sy_call_t *)rump_enosys }, /* 312 = unrumped */
1849 { 0, 0, 0, 1849 { 0, 0, 0,
1850 (sy_call_t *)rump_enosys }, /* 313 = unrumped */ 1850 (sy_call_t *)rump_enosys }, /* 313 = unrumped */
1851 { 0, 0, 0, 1851 { 0, 0, 0,
1852 (sy_call_t *)rump_enosys }, /* 314 = unrumped */ 1852 (sy_call_t *)rump_enosys }, /* 314 = unrumped */
1853 { 0, 0, 0, 1853 { 0, 0, 0,
1854 (sy_call_t *)rump_enosys }, /* 315 = unrumped */ 1854 (sy_call_t *)rump_enosys }, /* 315 = unrumped */
1855 { 0, 0, 0, 1855 { 0, 0, 0,
1856 (sy_call_t *)rump_enosys }, /* 316 = unrumped */ 1856 (sy_call_t *)rump_enosys }, /* 316 = unrumped */
1857 { 0, 0, 0, 1857 { 0, 0, 0,
1858 (sy_call_t *)rump_enosys }, /* 317 = unrumped */ 1858 (sy_call_t *)rump_enosys }, /* 317 = unrumped */
1859 { 0, 0, 0, 1859 { 0, 0, 0,
1860 (sy_call_t *)rump_enosys }, /* 318 = unrumped */ 1860 (sy_call_t *)rump_enosys }, /* 318 = unrumped */
1861 { 0, 0, 0, 1861 { 0, 0, 0,
1862 (sy_call_t *)rump_enosys }, /* 319 = unrumped */ 1862 (sy_call_t *)rump_enosys }, /* 319 = unrumped */
1863 { 0, 0, 0, 1863 { 0, 0, 0,
1864 (sy_call_t *)rump_enosys }, /* 320 = unrumped */ 1864 (sy_call_t *)rump_enosys }, /* 320 = unrumped */
1865 { 0, 0, 0, 1865 { 0, 0, 0,
1866 (sy_call_t *)rump_enosys }, /* 321 = unrumped */ 1866 (sy_call_t *)rump_enosys }, /* 321 = unrumped */
1867 { 0, 0, 0, 1867 { 0, 0, 0,
1868 (sy_call_t *)rump_enosys }, /* 322 = unrumped */ 1868 (sy_call_t *)rump_enosys }, /* 322 = unrumped */
1869 { 0, 0, 0, 1869 { 0, 0, 0,
1870 (sy_call_t *)rump_enosys }, /* 323 = unrumped */ 1870 (sy_call_t *)rump_enosys }, /* 323 = unrumped */
1871 { 0, 0, 0, 1871 { 0, 0, 0,
1872 (sy_call_t *)rump_enosys }, /* 324 = unrumped */ 1872 (sy_call_t *)rump_enosys }, /* 324 = unrumped */
1873 { 0, 0, 0, 1873 { 0, 0, 0,
1874 (sy_call_t *)rump_enosys }, /* 325 = unrumped */ 1874 (sy_call_t *)rump_enosys }, /* 325 = unrumped */
1875 { 0, 0, 0, 1875 { 0, 0, 0,
1876 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 1876 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */
1877 { 0, 0, 0, 1877 { 0, 0, 0,
1878 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 1878 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */
1879 { 0, 0, 0, 1879 { 0, 0, 0,
1880 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 1880 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */
1881 { 0, 0, 0, 1881 { 0, 0, 0,
1882 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 1882 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */
1883 { 0, 0, 0, 1883 { 0, 0, 0,
1884 (sy_call_t *)rump_enosys }, /* 330 = unrumped */ 1884 (sy_call_t *)rump_enosys }, /* 330 = unrumped */
1885 { 0, 0, 0, 1885 { 0, 0, 0,
1886 (sy_call_t *)rump_enosys }, /* 331 = unrumped */ 1886 (sy_call_t *)rump_enosys }, /* 331 = unrumped */
1887 { 0, 0, 0, 1887 { 0, 0, 0,
1888 (sy_call_t *)rump_enosys }, /* 332 = unrumped */ 1888 (sy_call_t *)rump_enosys }, /* 332 = unrumped */
1889 { 0, 0, 0, 1889 { 0, 0, 0,
1890 (sy_call_t *)rump_enosys }, /* 333 = unrumped */ 1890 (sy_call_t *)rump_enosys }, /* 333 = unrumped */
1891 { 0, 0, 0, 1891 { 0, 0, 0,
1892 (sy_call_t *)rump_enosys }, /* 334 = unrumped */ 1892 (sy_call_t *)rump_enosys }, /* 334 = unrumped */
1893 { 0, 0, 0, 1893 { 0, 0, 0,
1894 (sy_call_t *)rump_enosys }, /* 335 = unrumped */ 1894 (sy_call_t *)rump_enosys }, /* 335 = unrumped */
1895 { 0, 0, 0, 1895 { 0, 0, 0,
1896 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 1896 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */
1897 { 0, 0, 0, 1897 { 0, 0, 0,
1898 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 1898 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */
1899 { 0, 0, 0, 1899 { 0, 0, 0,
1900 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 1900 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */
1901 { 0, 0, 0, 1901 { 0, 0, 0,
1902 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 1902 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */
1903 { 0, 0, 0, 1903 { 0, 0, 0,
1904 (sy_call_t *)rump_enosys }, /* 340 = unrumped */ 1904 (sy_call_t *)rump_enosys }, /* 340 = unrumped */
1905 { 0, 0, 0, 1905 { 0, 0, 0,
1906 (sy_call_t *)rump_enosys }, /* 341 = unrumped */ 1906 (sy_call_t *)rump_enosys }, /* 341 = unrumped */
1907 { 0, 0, 0, 1907 { 0, 0, 0,
1908 (sy_call_t *)rump_enosys }, /* 342 = unrumped */ 1908 (sy_call_t *)rump_enosys }, /* 342 = unrumped */
1909 { 0, 0, 0, 1909 { 0, 0, 0,
1910 (sy_call_t *)rump_enosys }, /* 343 = unrumped */ 1910 (sy_call_t *)rump_enosys }, /* 343 = unrumped */
1911 { 0, 0, 0, 1911 { 0, 0, 0,
1912 (sy_call_t *)rump_enosys }, /* 344 = unrumped */ 1912 (sy_call_t *)rump_enosys }, /* 344 = unrumped */
1913 { 0, 0, 0, 1913 { 0, 0, 0,
1914 (sy_call_t *)rump_enosys }, /* 345 = unrumped */ 1914 (sy_call_t *)rump_enosys }, /* 345 = unrumped */
1915 { 0, 0, 0, 1915 { 0, 0, 0,
1916 (sy_call_t *)rump_enosys }, /* 346 = unrumped */ 1916 (sy_call_t *)rump_enosys }, /* 346 = unrumped */
1917 { 0, 0, 0, 1917 { 0, 0, 0,
1918 (sy_call_t *)rump_enosys }, /* 347 = unrumped */ 1918 (sy_call_t *)rump_enosys }, /* 347 = unrumped */
1919 { 0, 0, 0, 1919 { 0, 0, 0,
1920 (sy_call_t *)rump_enosys }, /* 348 = unrumped */ 1920 (sy_call_t *)rump_enosys }, /* 348 = unrumped */
1921 { 0, 0, 0, 1921 { 0, 0, 0,
1922 (sy_call_t *)rump_enosys }, /* 349 = unrumped */ 1922 (sy_call_t *)rump_enosys }, /* 349 = unrumped */
1923 { 0, 0, 0, 1923 { 0, 0, 0,
1924 (sy_call_t *)rump_enosys }, /* 350 = unrumped */ 1924 (sy_call_t *)rump_enosys }, /* 350 = unrumped */
1925 { 0, 0, 0, 1925 { 0, 0, 0,
1926 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 1926 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */
1927 { 0, 0, 0, 1927 { 0, 0, 0,
1928 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 1928 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */
1929 { 0, 0, 0, 1929 { 0, 0, 0,
1930 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 1930 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */
1931 { 0, 0, 0, 1931 { 0, 0, 0,
1932 (sy_call_t *)rump_enosys }, /* 354 = unrumped */ 1932 (sy_call_t *)rump_enosys }, /* 354 = unrumped */
1933 { 0, 0, 0, 1933 { 0, 0, 0,
1934 (sy_call_t *)rump_enosys }, /* 355 = unrumped */ 1934 (sy_call_t *)rump_enosys }, /* 355 = unrumped */
1935 { 0, 0, 0, 1935 { 0, 0, 0,
1936 (sy_call_t *)rump_enosys }, /* 356 = unrumped */ 1936 (sy_call_t *)rump_enosys }, /* 356 = unrumped */
1937 { ns(struct sys_statvfs1_args), 0, 1937 { ns(struct sys_statvfs1_args), 0,
1938 (sy_call_t *)sys_statvfs1 }, /* 357 = statvfs1 */ 1938 (sy_call_t *)sys_statvfs1 }, /* 357 = statvfs1 */
1939 { 0, 0, 0, 1939 { 0, 0, 0,
1940 (sy_call_t *)rump_enosys }, /* 358 = unrumped */ 1940 (sy_call_t *)rump_enosys }, /* 358 = unrumped */
1941 { 0, 0, 0, 1941 { 0, 0, 0,
1942 (sy_call_t *)rump_enosys }, /* 359 = unrumped */ 1942 (sy_call_t *)rump_enosys }, /* 359 = unrumped */
1943 { 0, 0, 0, 1943 { 0, 0, 0,
1944 (sy_call_t *)rump_enosys }, /* 360 = unrumped */ 1944 (sy_call_t *)rump_enosys }, /* 360 = unrumped */
1945 { 0, 0, 0, 1945 { 0, 0, 0,
1946 (sy_call_t *)rump_enosys }, /* 361 = unrumped */ 1946 (sy_call_t *)rump_enosys }, /* 361 = unrumped */
1947 { 0, 0, 0, 1947 { 0, 0, 0,
1948 (sy_call_t *)rump_enosys }, /* 362 = unrumped */ 1948 (sy_call_t *)rump_enosys }, /* 362 = unrumped */
1949 { 0, 0, 0, 1949 { 0, 0, 0,
1950 (sy_call_t *)rump_enosys }, /* 363 = unrumped */ 1950 (sy_call_t *)rump_enosys }, /* 363 = unrumped */
1951 { 0, 0, 0, 1951 { 0, 0, 0,
1952 (sy_call_t *)rump_enosys }, /* 364 = unrumped */ 1952 (sy_call_t *)rump_enosys }, /* 364 = unrumped */
1953 { 0, 0, 0, 1953 { 0, 0, 0,
1954 (sy_call_t *)rump_enosys }, /* 365 = unrumped */ 1954 (sy_call_t *)rump_enosys }, /* 365 = unrumped */
1955 { 0, 0, 0, 1955 { 0, 0, 0,
1956 (sy_call_t *)rump_enosys }, /* 366 = unrumped */ 1956 (sy_call_t *)rump_enosys }, /* 366 = unrumped */
1957 { 0, 0, 0, 1957 { 0, 0, 0,
1958 (sy_call_t *)rump_enosys }, /* 367 = unrumped */ 1958 (sy_call_t *)rump_enosys }, /* 367 = unrumped */
1959 { 0, 0, 0, 1959 { 0, 0, 0,
1960 (sy_call_t *)rump_enosys }, /* 368 = unrumped */ 1960 (sy_call_t *)rump_enosys }, /* 368 = unrumped */
1961 { 0, 0, 0, 1961 { 0, 0, 0,
1962 (sy_call_t *)rump_enosys }, /* 369 = unrumped */ 1962 (sy_call_t *)rump_enosys }, /* 369 = unrumped */
1963 { 0, 0, 0, 1963 { 0, 0, 0,
1964 (sy_call_t *)rump_enosys }, /* 370 = unrumped */ 1964 (sy_call_t *)rump_enosys }, /* 370 = unrumped */
1965 { 0, 0, 0, 1965 { 0, 0, 0,
1966 (sy_call_t *)rump_enosys }, /* 371 = unrumped */ 1966 (sy_call_t *)rump_enosys }, /* 371 = unrumped */
1967 { 0, 0, 0, 1967 { 0, 0, 0,
1968 (sy_call_t *)rump_enosys }, /* 372 = unrumped */ 1968 (sy_call_t *)rump_enosys }, /* 372 = unrumped */
1969 { 0, 0, 0, 1969 { 0, 0, 0,
1970 (sy_call_t *)rump_enosys }, /* 373 = unrumped */ 1970 (sy_call_t *)rump_enosys }, /* 373 = unrumped */
1971 { 0, 0, 0, 1971 { 0, 0, 0,
1972 (sy_call_t *)rump_enosys }, /* 374 = unrumped */ 1972 (sy_call_t *)rump_enosys }, /* 374 = unrumped */
1973 { 0, 0, 0, 1973 { 0, 0, 0,
1974 (sy_call_t *)rump_enosys }, /* 375 = unrumped */ 1974 (sy_call_t *)rump_enosys }, /* 375 = unrumped */
1975 { 0, 0, 0, 1975 { 0, 0, 0,
1976 (sy_call_t *)rump_enosys }, /* 376 = unrumped */ 1976 (sy_call_t *)rump_enosys }, /* 376 = unrumped */
1977 { 0, 0, 0, 1977 { 0, 0, 0,
1978 (sy_call_t *)rump_enosys }, /* 377 = unrumped */ 1978 (sy_call_t *)rump_enosys }, /* 377 = unrumped */
1979 { 0, 0, 0, 1979 { 0, 0, 0,
1980 (sy_call_t *)rump_enosys }, /* 378 = unrumped */ 1980 (sy_call_t *)rump_enosys }, /* 378 = unrumped */
1981 { 0, 0, 0, 1981 { 0, 0, 0,
1982 (sy_call_t *)rump_enosys }, /* 379 = unrumped */ 1982 (sy_call_t *)rump_enosys }, /* 379 = unrumped */
1983 { 0, 0, 0, 1983 { 0, 0, 0,
1984 (sy_call_t *)rump_enosys }, /* 380 = unrumped */ 1984 (sy_call_t *)rump_enosys }, /* 380 = unrumped */
1985 { 0, 0, 0, 1985 { 0, 0, 0,
1986 (sy_call_t *)rump_enosys }, /* 381 = unrumped */ 1986 (sy_call_t *)rump_enosys }, /* 381 = unrumped */
1987 { 0, 0, 0, 1987 { 0, 0, 0,
1988 (sy_call_t *)rump_enosys }, /* 382 = unrumped */ 1988 (sy_call_t *)rump_enosys }, /* 382 = unrumped */
1989 { 0, 0, 0, 1989 { 0, 0, 0,
1990 (sy_call_t *)rump_enosys }, /* 383 = unrumped */ 1990 (sy_call_t *)rump_enosys }, /* 383 = unrumped */
1991 { 0, 0, 0, 1991 { 0, 0, 0,
1992 (sy_call_t *)rump_enosys }, /* 384 = unrumped */ 1992 (sy_call_t *)rump_enosys }, /* 384 = unrumped */
1993 { 0, 0, 0, 1993 { 0, 0, 0,
1994 (sy_call_t *)rump_enosys }, /* 385 = unrumped */ 1994 (sy_call_t *)rump_enosys }, /* 385 = unrumped */
1995 { 0, 0, 0, 1995 { 0, 0, 0,
1996 (sy_call_t *)rump_enosys }, /* 386 = unrumped */ 1996 (sy_call_t *)rump_enosys }, /* 386 = unrumped */
1997 { 0, 0, 0, 1997 { 0, 0, 0,
1998 (sy_call_t *)rump_enosys }, /* 387 = unrumped */ 1998 (sy_call_t *)rump_enosys }, /* 387 = unrumped */
1999 { 0, 0, 0, 1999 { 0, 0, 0,
2000 (sy_call_t *)rump_enosys }, /* 388 = unrumped */ 2000 (sy_call_t *)rump_enosys }, /* 388 = unrumped */
2001 { 0, 0, 0, 2001 { 0, 0, 0,
2002 (sy_call_t *)rump_enosys }, /* 389 = unrumped */ 2002 (sy_call_t *)rump_enosys }, /* 389 = unrumped */
2003 { 0, 0, 0, 2003 { 0, 0, 0,
2004 (sy_call_t *)rump_enosys }, /* 390 = unrumped */ 2004 (sy_call_t *)rump_enosys }, /* 390 = unrumped */
2005 { 0, 0, 0, 2005 { 0, 0, 0,
2006 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 2006 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */
2007 { 0, 0, 0, 2007 { 0, 0, 0,
2008 (sy_call_t *)rump_enosys }, /* 392 = unrumped */ 2008 (sy_call_t *)rump_enosys }, /* 392 = unrumped */
2009 { 0, 0, 0, 2009 { 0, 0, 0,
2010 (sy_call_t *)rump_enosys }, /* 393 = unrumped */ 2010 (sy_call_t *)rump_enosys }, /* 393 = unrumped */
2011 { ns(struct sys___socket30_args), 0, 2011 { ns(struct sys___socket30_args), 0,
2012 (sy_call_t *)sys___socket30 }, /* 394 = __socket30 */ 2012 (sy_call_t *)sys___socket30 }, /* 394 = __socket30 */
2013 { ns(struct sys___getfh30_args), 0, 2013 { ns(struct sys___getfh30_args), 0,
2014 (sy_call_t *)sys___getfh30 }, /* 395 = __getfh30 */ 2014 (sy_call_t *)sys___getfh30 }, /* 395 = __getfh30 */
2015 { 0, 0, 0, 2015 { 0, 0, 0,
2016 (sy_call_t *)rump_enosys }, /* 396 = unrumped */ 2016 (sy_call_t *)rump_enosys }, /* 396 = unrumped */
2017 { 0, 0, 0, 2017 { 0, 0, 0,
2018 (sy_call_t *)rump_enosys }, /* 397 = unrumped */ 2018 (sy_call_t *)rump_enosys }, /* 397 = unrumped */
2019 { 0, 0, 0, 2019 { 0, 0, 0,
2020 (sy_call_t *)rump_enosys }, /* 398 = unrumped */ 2020 (sy_call_t *)rump_enosys }, /* 398 = unrumped */
2021 { 0, 0, 0, 2021 { 0, 0, 0,
2022 (sy_call_t *)rump_enosys }, /* 399 = unrumped */ 2022 (sy_call_t *)rump_enosys }, /* 399 = unrumped */
2023 { 0, 0, 0, 2023 { 0, 0, 0,
2024 (sy_call_t *)rump_enosys }, /* 400 = unrumped */ 2024 (sy_call_t *)rump_enosys }, /* 400 = unrumped */
2025 { 0, 0, 0, 2025 { 0, 0, 0,
2026 (sy_call_t *)rump_enosys }, /* 401 = unrumped */ 2026 (sy_call_t *)rump_enosys }, /* 401 = unrumped */
2027 { 0, 0, 0, 2027 { 0, 0, 0,
2028 (sy_call_t *)rump_enosys }, /* 402 = unrumped */ 2028 (sy_call_t *)rump_enosys }, /* 402 = unrumped */
2029 { 0, 0, 0, 2029 { 0, 0, 0,
2030 (sy_call_t *)rump_enosys }, /* 403 = unrumped */ 2030 (sy_call_t *)rump_enosys }, /* 403 = unrumped */
2031 { 0, 0, 0, 2031 { 0, 0, 0,
2032 (sy_call_t *)rump_enosys }, /* 404 = unrumped */ 2032 (sy_call_t *)rump_enosys }, /* 404 = unrumped */
2033 { 0, 0, 0, 2033 { 0, 0, 0,
2034 (sy_call_t *)rump_enosys }, /* 405 = unrumped */ 2034 (sy_call_t *)rump_enosys }, /* 405 = unrumped */
2035 { 0, 0, 0, 2035 { 0, 0, 0,
2036 (sy_call_t *)rump_enosys }, /* 406 = unrumped */ 2036 (sy_call_t *)rump_enosys }, /* 406 = unrumped */
2037 { 0, 0, 0, 2037 { 0, 0, 0,
2038 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 2038 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */
2039 { 0, 0, 0, 2039 { 0, 0, 0,
2040 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 2040 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */
2041 { 0, 0, 0, 2041 { 0, 0, 0,
2042 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 2042 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */
2043 { 0, 0, 0, 2043 { 0, 0, 0,
2044 (sy_call_t *)rump_enosys }, /* 410 = unrumped */ 2044 (sy_call_t *)rump_enosys }, /* 410 = unrumped */
2045 { 0, 0, 0, 2045 { 0, 0, 0,
2046 (sy_call_t *)rump_enosys }, /* 411 = unrumped */ 2046 (sy_call_t *)rump_enosys }, /* 411 = unrumped */
2047 { 0, 0, 0, 2047 { 0, 0, 0,
2048 (sy_call_t *)rump_enosys }, /* 412 = unrumped */ 2048 (sy_call_t *)rump_enosys }, /* 412 = unrumped */
2049 { 0, 0, 0, 2049 { 0, 0, 0,
2050 (sy_call_t *)rump_enosys }, /* 413 = unrumped */ 2050 (sy_call_t *)rump_enosys }, /* 413 = unrumped */
2051 { 0, 0, 0, 2051 { 0, 0, 0,
2052 (sy_call_t *)rump_enosys }, /* 414 = unrumped */ 2052 (sy_call_t *)rump_enosys }, /* 414 = unrumped */
2053 { 0, 0, 0, 2053 { 0, 0, 0,
2054 (sy_call_t *)rump_enosys }, /* 415 = unrumped */ 2054 (sy_call_t *)rump_enosys }, /* 415 = unrumped */
2055 { 0, 0, 0, 2055 { 0, 0, 0,
2056 (sy_call_t *)rump_enosys }, /* 416 = unrumped */ 2056 (sy_call_t *)rump_enosys }, /* 416 = unrumped */
2057 { 0, 0, 0, 2057 { 0, 0, 0,
2058 (sy_call_t *)rump_enosys }, /* 417 = unrumped */ 2058 (sy_call_t *)rump_enosys }, /* 417 = unrumped */
2059 { 0, 0, 0, 2059 { 0, 0, 0,
2060 (sy_call_t *)rump_enosys }, /* 418 = unrumped */ 2060 (sy_call_t *)rump_enosys }, /* 418 = unrumped */
2061 { 0, 0, 0, 2061 { 0, 0, 0,
2062 (sy_call_t *)rump_enosys }, /* 419 = unrumped */ 2062 (sy_call_t *)rump_enosys }, /* 419 = unrumped */
2063 { ns(struct sys___utimes50_args), 0, 2063 { ns(struct sys___utimes50_args), 0,
2064 (sy_call_t *)sys___utimes50 }, /* 420 = __utimes50 */ 2064 (sy_call_t *)sys___utimes50 }, /* 420 = __utimes50 */
2065 { 0, 0, 0, 2065 { 0, 0, 0,
2066 (sy_call_t *)rump_enosys }, /* 421 = unrumped */ 2066 (sy_call_t *)rump_enosys }, /* 421 = unrumped */
2067#if defined(LFS) || !defined(_KERNEL) 2067#if defined(LFS) || !defined(_KERNEL)
2068 { 0, 0, 0, 2068 { 0, 0, 0,
2069 (sy_call_t *)rump_enosys }, /* 422 = unrumped */ 2069 (sy_call_t *)rump_enosys }, /* 422 = unrumped */
2070#else 2070#else
2071 { 0, 0, 0, 2071 { 0, 0, 0,
2072 (sy_call_t *)rump_enosys }, /* 422 = excluded __lfs_segwait50 */ 2072 (sy_call_t *)rump_enosys }, /* 422 = excluded __lfs_segwait50 */
2073#endif 2073#endif
2074 { 0, 0, 0, 2074 { 0, 0, 0,
2075 (sy_call_t *)rump_enosys }, /* 423 = unrumped */ 2075 (sy_call_t *)rump_enosys }, /* 423 = unrumped */
2076 { ns(struct sys___lutimes50_args), 0, 2076 { ns(struct sys___lutimes50_args), 0,
2077 (sy_call_t *)sys___lutimes50 }, /* 424 = __lutimes50 */ 2077 (sy_call_t *)sys___lutimes50 }, /* 424 = __lutimes50 */
2078 { 0, 0, 0, 2078 { 0, 0, 0,
2079 (sy_call_t *)rump_enosys }, /* 425 = unrumped */ 2079 (sy_call_t *)rump_enosys }, /* 425 = unrumped */
2080 { 0, 0, 0, 2080 { 0, 0, 0,
2081 (sy_call_t *)rump_enosys }, /* 426 = unrumped */ 2081 (sy_call_t *)rump_enosys }, /* 426 = unrumped */
2082 { 0, 0, 0, 2082 { 0, 0, 0,
2083 (sy_call_t *)rump_enosys }, /* 427 = unrumped */ 2083 (sy_call_t *)rump_enosys }, /* 427 = unrumped */
2084 { 0, 0, 0, 2084 { 0, 0, 0,
2085 (sy_call_t *)rump_enosys }, /* 428 = unrumped */ 2085 (sy_call_t *)rump_enosys }, /* 428 = unrumped */
2086 { 0, 0, 0, 2086 { 0, 0, 0,
2087 (sy_call_t *)rump_enosys }, /* 429 = unrumped */ 2087 (sy_call_t *)rump_enosys }, /* 429 = unrumped */
2088 { 0, 0, 0, 2088 { 0, 0, 0,
2089 (sy_call_t *)rump_enosys }, /* 430 = unrumped */ 2089 (sy_call_t *)rump_enosys }, /* 430 = unrumped */
2090 { 0, 0, 0, 2090 { 0, 0, 0,
2091 (sy_call_t *)rump_enosys }, /* 431 = unrumped */ 2091 (sy_call_t *)rump_enosys }, /* 431 = unrumped */
2092 { 0, 0, 0, 2092 { 0, 0, 0,
2093 (sy_call_t *)rump_enosys }, /* 432 = unrumped */ 2093 (sy_call_t *)rump_enosys }, /* 432 = unrumped */
2094 { 0, 0, 0, 2094 { 0, 0, 0,
2095 (sy_call_t *)rump_enosys }, /* 433 = unrumped */ 2095 (sy_call_t *)rump_enosys }, /* 433 = unrumped */
2096 { 0, 0, 0, 2096 { 0, 0, 0,
2097 (sy_call_t *)rump_enosys }, /* 434 = unrumped */ 2097 (sy_call_t *)rump_enosys }, /* 434 = unrumped */
2098 { 0, 0, 0, 2098 { 0, 0, 0,
2099 (sy_call_t *)rump_enosys }, /* 435 = unrumped */ 2099 (sy_call_t *)rump_enosys }, /* 435 = unrumped */
2100 { 0, 0, 0, 2100 { 0, 0, 0,
2101 (sy_call_t *)rump_enosys }, /* 436 = unrumped */ 2101 (sy_call_t *)rump_enosys }, /* 436 = unrumped */
2102 { 0, 0, 0, 2102 { 0, 0, 0,
2103 (sy_call_t *)rump_enosys }, /* 437 = unrumped */ 2103 (sy_call_t *)rump_enosys }, /* 437 = unrumped */
2104 { 0, 0, 0, 2104 { 0, 0, 0,
2105 (sy_call_t *)rump_enosys }, /* 438 = unrumped */ 2105 (sy_call_t *)rump_enosys }, /* 438 = unrumped */
2106 { ns(struct sys___stat50_args), 0, 2106 { ns(struct sys___stat50_args), 0,
2107 (sy_call_t *)sys___stat50 }, /* 439 = __stat50 */ 2107 (sy_call_t *)sys___stat50 }, /* 439 = __stat50 */
2108 { 0, 0, 0, 2108 { 0, 0, 0,
2109 (sy_call_t *)rump_enosys }, /* 440 = unrumped */ 2109 (sy_call_t *)rump_enosys }, /* 440 = unrumped */
2110 { ns(struct sys___lstat50_args), 0, 2110 { ns(struct sys___lstat50_args), 0,
2111 (sy_call_t *)sys___lstat50 }, /* 441 = __lstat50 */ 2111 (sy_call_t *)sys___lstat50 }, /* 441 = __lstat50 */
2112#if defined(SYSVSEM) || !defined(_KERNEL_OPT) 2112#if defined(SYSVSEM) || !defined(_KERNEL_OPT)
2113 { 0, 0, 0, 2113 { 0, 0, 0,
2114 (sy_call_t *)rump_enosys }, /* 442 = unrumped */ 2114 (sy_call_t *)rump_enosys }, /* 442 = unrumped */
2115#else 2115#else
2116 { 0, 0, 0, 2116 { 0, 0, 0,
2117 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 2117 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */
2118#endif 2118#endif
2119#if defined(SYSVSHM) || !defined(_KERNEL_OPT) 2119#if defined(SYSVSHM) || !defined(_KERNEL_OPT)
2120 { 0, 0, 0, 2120 { 0, 0, 0,
2121 (sy_call_t *)rump_enosys }, /* 443 = unrumped */ 2121 (sy_call_t *)rump_enosys }, /* 443 = unrumped */
2122#else 2122#else
2123 { 0, 0, 0, 2123 { 0, 0, 0,
2124 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 2124 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */
2125#endif 2125#endif
2126#if defined(SYSVMSG) || !defined(_KERNEL_OPT) 2126#if defined(SYSVMSG) || !defined(_KERNEL_OPT)
2127 { 0, 0, 0, 2127 { 0, 0, 0,
2128 (sy_call_t *)rump_enosys }, /* 444 = unrumped */ 2128 (sy_call_t *)rump_enosys }, /* 444 = unrumped */
2129#else 2129#else