xref: /netbsd-src/sys/rump/librump/rumpkern/rump_syscalls.c (revision ef55f7213a1caf3f68075f7a0f424adb0a6add00)
1 /* $NetBSD: rump_syscalls.c,v 1.164 2024/10/09 16:29:11 christos Exp $ */
2 
3 /*
4  * System call vector and marshalling for rump.
5  *
6  * DO NOT EDIT-- this file is automatically generated.
7  * created from	NetBSD: syscalls.master,v 1.316 2024/10/09 16:27:28 christos Exp
8  */
9 
10 #ifdef RUMP_CLIENT
11 #include <rump/rumpuser_port.h>
12 #endif /* RUMP_CLIENT */
13 
14 #include <sys/param.h>
15 
16 #ifdef __NetBSD__
17 #include <sys/cdefs.h>
18 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.164 2024/10/09 16:29:11 christos Exp $");
19 
20 #include <sys/fstypes.h>
21 #include <sys/proc.h>
22 #endif /* __NetBSD__ */
23 
24 #ifdef RUMP_CLIENT
25 #include <errno.h>
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29 
30 #include <srcsys/syscall.h>
31 #include <srcsys/syscallargs.h>
32 
33 #include <rump/rumpclient.h>
34 
35 #define rsys_syscall(num, data, dlen, retval)	\
36     rumpclient_syscall(num, data, dlen, retval)
37 #define rsys_seterrno(error) errno = error
38 #else
39 #include <sys/syscall.h>
40 #include <sys/syscallargs.h>
41 
42 #include <sys/syscallvar.h>
43 
44 #include <rump-sys/kern.h>
45 
46 #include <rump/rumpuser.h>
47 #define rsys_syscall(num, data, dlen, retval)	\
48     rump_syscall(num, data, dlen, retval)
49 
50 #define rsys_seterrno(error) rumpuser_seterrno(error)
51 #endif
52 
53 #ifndef RUMP_KERNEL_IS_LIBC
54 #define RUMP_SYS_COMPAT
55 #endif
56 
57 #if	BYTE_ORDER == BIG_ENDIAN
58 #define SPARG(p,k)	((p)->k.be.datum)
59 #else /* LITTLE_ENDIAN, I hope dearly */
60 #define SPARG(p,k)	((p)->k.le.datum)
61 #endif
62 
63 
64 void rumpns_sys_nomodule(void);
65 
66 ssize_t rump___sysimpl_read(int, void *, size_t);
67 ssize_t
68 rump___sysimpl_read(int fd, void * buf, size_t nbyte)
69 {
70 	register_t retval[2];
71 	int error = 0;
72 	ssize_t rv = -1;
73 	struct sys_read_args callarg;
74 
75 	memset(&callarg, 0, sizeof(callarg));
76 	SPARG(&callarg, fd) = fd;
77 	SPARG(&callarg, buf) = buf;
78 	SPARG(&callarg, nbyte) = nbyte;
79 
80 	error = rsys_syscall(SYS_read, &callarg, sizeof(callarg), retval);
81 	rsys_seterrno(error);
82 	if (error == 0) {
83 		if (sizeof(ssize_t) > sizeof(register_t))
84 			rv = *(ssize_t *)retval;
85 		else
86 			rv = *retval;
87 	}
88 	return rv;
89 }
90 #ifdef RUMP_KERNEL_IS_LIBC
91 __weak_alias(read,rump___sysimpl_read);
92 __weak_alias(_read,rump___sysimpl_read);
93 __strong_alias(_sys_read,rump___sysimpl_read);
94 #endif /* RUMP_KERNEL_IS_LIBC */
95 
96 ssize_t rump___sysimpl_write(int, const void *, size_t);
97 ssize_t
98 rump___sysimpl_write(int fd, const void * buf, size_t nbyte)
99 {
100 	register_t retval[2];
101 	int error = 0;
102 	ssize_t rv = -1;
103 	struct sys_write_args callarg;
104 
105 	memset(&callarg, 0, sizeof(callarg));
106 	SPARG(&callarg, fd) = fd;
107 	SPARG(&callarg, buf) = buf;
108 	SPARG(&callarg, nbyte) = nbyte;
109 
110 	error = rsys_syscall(SYS_write, &callarg, sizeof(callarg), retval);
111 	rsys_seterrno(error);
112 	if (error == 0) {
113 		if (sizeof(ssize_t) > sizeof(register_t))
114 			rv = *(ssize_t *)retval;
115 		else
116 			rv = *retval;
117 	}
118 	return rv;
119 }
120 #ifdef RUMP_KERNEL_IS_LIBC
121 __weak_alias(write,rump___sysimpl_write);
122 __weak_alias(_write,rump___sysimpl_write);
123 __strong_alias(_sys_write,rump___sysimpl_write);
124 #endif /* RUMP_KERNEL_IS_LIBC */
125 
126 int rump___sysimpl_open(const char *, int, mode_t);
127 int
128 rump___sysimpl_open(const char * path, int flags, mode_t mode)
129 {
130 	register_t retval[2];
131 	int error = 0;
132 	int rv = -1;
133 	struct sys_open_args callarg;
134 
135 	memset(&callarg, 0, sizeof(callarg));
136 	SPARG(&callarg, path) = path;
137 	SPARG(&callarg, flags) = flags;
138 	SPARG(&callarg, mode) = mode;
139 
140 	error = rsys_syscall(SYS_open, &callarg, sizeof(callarg), retval);
141 	rsys_seterrno(error);
142 	if (error == 0) {
143 		if (sizeof(int) > sizeof(register_t))
144 			rv = *(int *)retval;
145 		else
146 			rv = *retval;
147 	}
148 	return rv;
149 }
150 #ifdef RUMP_KERNEL_IS_LIBC
151 __weak_alias(open,rump___sysimpl_open);
152 __weak_alias(_open,rump___sysimpl_open);
153 __strong_alias(_sys_open,rump___sysimpl_open);
154 #endif /* RUMP_KERNEL_IS_LIBC */
155 
156 int rump___sysimpl_close(int);
157 int
158 rump___sysimpl_close(int fd)
159 {
160 	register_t retval[2];
161 	int error = 0;
162 	int rv = -1;
163 	struct sys_close_args callarg;
164 
165 	memset(&callarg, 0, sizeof(callarg));
166 	SPARG(&callarg, fd) = fd;
167 
168 	error = rsys_syscall(SYS_close, &callarg, sizeof(callarg), retval);
169 	rsys_seterrno(error);
170 	if (error == 0) {
171 		if (sizeof(int) > sizeof(register_t))
172 			rv = *(int *)retval;
173 		else
174 			rv = *retval;
175 	}
176 	return rv;
177 }
178 #ifdef RUMP_KERNEL_IS_LIBC
179 __weak_alias(close,rump___sysimpl_close);
180 __weak_alias(_close,rump___sysimpl_close);
181 __strong_alias(_sys_close,rump___sysimpl_close);
182 #endif /* RUMP_KERNEL_IS_LIBC */
183 
184 int rump___sysimpl_link(const char *, const char *);
185 int
186 rump___sysimpl_link(const char * path, const char * link)
187 {
188 	register_t retval[2];
189 	int error = 0;
190 	int rv = -1;
191 	struct sys_link_args callarg;
192 
193 	memset(&callarg, 0, sizeof(callarg));
194 	SPARG(&callarg, path) = path;
195 	SPARG(&callarg, link) = link;
196 
197 	error = rsys_syscall(SYS_link, &callarg, sizeof(callarg), retval);
198 	rsys_seterrno(error);
199 	if (error == 0) {
200 		if (sizeof(int) > sizeof(register_t))
201 			rv = *(int *)retval;
202 		else
203 			rv = *retval;
204 	}
205 	return rv;
206 }
207 #ifdef RUMP_KERNEL_IS_LIBC
208 __weak_alias(link,rump___sysimpl_link);
209 __weak_alias(_link,rump___sysimpl_link);
210 __strong_alias(_sys_link,rump___sysimpl_link);
211 #endif /* RUMP_KERNEL_IS_LIBC */
212 
213 int rump___sysimpl_unlink(const char *);
214 int
215 rump___sysimpl_unlink(const char * path)
216 {
217 	register_t retval[2];
218 	int error = 0;
219 	int rv = -1;
220 	struct sys_unlink_args callarg;
221 
222 	memset(&callarg, 0, sizeof(callarg));
223 	SPARG(&callarg, path) = path;
224 
225 	error = rsys_syscall(SYS_unlink, &callarg, sizeof(callarg), retval);
226 	rsys_seterrno(error);
227 	if (error == 0) {
228 		if (sizeof(int) > sizeof(register_t))
229 			rv = *(int *)retval;
230 		else
231 			rv = *retval;
232 	}
233 	return rv;
234 }
235 #ifdef RUMP_KERNEL_IS_LIBC
236 __weak_alias(unlink,rump___sysimpl_unlink);
237 __weak_alias(_unlink,rump___sysimpl_unlink);
238 __strong_alias(_sys_unlink,rump___sysimpl_unlink);
239 #endif /* RUMP_KERNEL_IS_LIBC */
240 
241 int rump___sysimpl_chdir(const char *);
242 int
243 rump___sysimpl_chdir(const char * path)
244 {
245 	register_t retval[2];
246 	int error = 0;
247 	int rv = -1;
248 	struct sys_chdir_args callarg;
249 
250 	memset(&callarg, 0, sizeof(callarg));
251 	SPARG(&callarg, path) = path;
252 
253 	error = rsys_syscall(SYS_chdir, &callarg, sizeof(callarg), retval);
254 	rsys_seterrno(error);
255 	if (error == 0) {
256 		if (sizeof(int) > sizeof(register_t))
257 			rv = *(int *)retval;
258 		else
259 			rv = *retval;
260 	}
261 	return rv;
262 }
263 #ifdef RUMP_KERNEL_IS_LIBC
264 __weak_alias(chdir,rump___sysimpl_chdir);
265 __weak_alias(_chdir,rump___sysimpl_chdir);
266 __strong_alias(_sys_chdir,rump___sysimpl_chdir);
267 #endif /* RUMP_KERNEL_IS_LIBC */
268 
269 int rump___sysimpl_fchdir(int);
270 int
271 rump___sysimpl_fchdir(int fd)
272 {
273 	register_t retval[2];
274 	int error = 0;
275 	int rv = -1;
276 	struct sys_fchdir_args callarg;
277 
278 	memset(&callarg, 0, sizeof(callarg));
279 	SPARG(&callarg, fd) = fd;
280 
281 	error = rsys_syscall(SYS_fchdir, &callarg, sizeof(callarg), retval);
282 	rsys_seterrno(error);
283 	if (error == 0) {
284 		if (sizeof(int) > sizeof(register_t))
285 			rv = *(int *)retval;
286 		else
287 			rv = *retval;
288 	}
289 	return rv;
290 }
291 #ifdef RUMP_KERNEL_IS_LIBC
292 __weak_alias(fchdir,rump___sysimpl_fchdir);
293 __weak_alias(_fchdir,rump___sysimpl_fchdir);
294 __strong_alias(_sys_fchdir,rump___sysimpl_fchdir);
295 #endif /* RUMP_KERNEL_IS_LIBC */
296 
297 #ifdef RUMP_SYS_COMPAT
298 int rump___sysimpl_mknod(const char *, mode_t, uint32_t);
299 int
300 rump___sysimpl_mknod(const char * path, mode_t mode, uint32_t dev)
301 {
302 	register_t retval[2];
303 	int error = 0;
304 	int rv = -1;
305 	struct compat_50_sys_mknod_args callarg;
306 
307 	memset(&callarg, 0, sizeof(callarg));
308 	SPARG(&callarg, path) = path;
309 	SPARG(&callarg, mode) = mode;
310 	SPARG(&callarg, dev) = dev;
311 
312 	error = rsys_syscall(SYS_compat_50_mknod, &callarg, sizeof(callarg), retval);
313 	rsys_seterrno(error);
314 	if (error == 0) {
315 		if (sizeof(int) > sizeof(register_t))
316 			rv = *(int *)retval;
317 		else
318 			rv = *retval;
319 	}
320 	return rv;
321 }
322 #ifdef RUMP_KERNEL_IS_LIBC
323 __weak_alias(mknod,rump___sysimpl_mknod);
324 __weak_alias(_mknod,rump___sysimpl_mknod);
325 __strong_alias(_sys_mknod,rump___sysimpl_mknod);
326 #endif /* RUMP_KERNEL_IS_LIBC */
327 #endif /* RUMP_SYS_COMPAT */
328 
329 int rump___sysimpl_chmod(const char *, mode_t);
330 int
331 rump___sysimpl_chmod(const char * path, mode_t mode)
332 {
333 	register_t retval[2];
334 	int error = 0;
335 	int rv = -1;
336 	struct sys_chmod_args callarg;
337 
338 	memset(&callarg, 0, sizeof(callarg));
339 	SPARG(&callarg, path) = path;
340 	SPARG(&callarg, mode) = mode;
341 
342 	error = rsys_syscall(SYS_chmod, &callarg, sizeof(callarg), retval);
343 	rsys_seterrno(error);
344 	if (error == 0) {
345 		if (sizeof(int) > sizeof(register_t))
346 			rv = *(int *)retval;
347 		else
348 			rv = *retval;
349 	}
350 	return rv;
351 }
352 #ifdef RUMP_KERNEL_IS_LIBC
353 __weak_alias(chmod,rump___sysimpl_chmod);
354 __weak_alias(_chmod,rump___sysimpl_chmod);
355 __strong_alias(_sys_chmod,rump___sysimpl_chmod);
356 #endif /* RUMP_KERNEL_IS_LIBC */
357 
358 int rump___sysimpl_chown(const char *, uid_t, gid_t);
359 int
360 rump___sysimpl_chown(const char * path, uid_t uid, gid_t gid)
361 {
362 	register_t retval[2];
363 	int error = 0;
364 	int rv = -1;
365 	struct sys_chown_args callarg;
366 
367 	memset(&callarg, 0, sizeof(callarg));
368 	SPARG(&callarg, path) = path;
369 	SPARG(&callarg, uid) = uid;
370 	SPARG(&callarg, gid) = gid;
371 
372 	error = rsys_syscall(SYS_chown, &callarg, sizeof(callarg), retval);
373 	rsys_seterrno(error);
374 	if (error == 0) {
375 		if (sizeof(int) > sizeof(register_t))
376 			rv = *(int *)retval;
377 		else
378 			rv = *retval;
379 	}
380 	return rv;
381 }
382 #ifdef RUMP_KERNEL_IS_LIBC
383 __weak_alias(chown,rump___sysimpl_chown);
384 __weak_alias(_chown,rump___sysimpl_chown);
385 __strong_alias(_sys_chown,rump___sysimpl_chown);
386 #endif /* RUMP_KERNEL_IS_LIBC */
387 
388 pid_t rump___sysimpl_getpid(void);
389 pid_t
390 rump___sysimpl_getpid(void )
391 {
392 	register_t retval[2];
393 	pid_t rv = -1;
394 
395 	(void)rsys_syscall(SYS_getpid, NULL, 0, retval);
396 	if (sizeof(pid_t) > sizeof(register_t))
397 		rv = *(pid_t *)retval;
398 	else
399 		rv = *retval;
400 	return rv;
401 }
402 #ifdef RUMP_KERNEL_IS_LIBC
403 __weak_alias(getpid,rump___sysimpl_getpid);
404 __weak_alias(_getpid,rump___sysimpl_getpid);
405 __strong_alias(_sys_getpid,rump___sysimpl_getpid);
406 #endif /* RUMP_KERNEL_IS_LIBC */
407 
408 int rump___sysimpl_unmount(const char *, int);
409 int
410 rump___sysimpl_unmount(const char * path, int flags)
411 {
412 	register_t retval[2];
413 	int error = 0;
414 	int rv = -1;
415 	struct sys_unmount_args callarg;
416 
417 	memset(&callarg, 0, sizeof(callarg));
418 	SPARG(&callarg, path) = path;
419 	SPARG(&callarg, flags) = flags;
420 
421 	error = rsys_syscall(SYS_unmount, &callarg, sizeof(callarg), retval);
422 	rsys_seterrno(error);
423 	if (error == 0) {
424 		if (sizeof(int) > sizeof(register_t))
425 			rv = *(int *)retval;
426 		else
427 			rv = *retval;
428 	}
429 	return rv;
430 }
431 #ifdef RUMP_KERNEL_IS_LIBC
432 __weak_alias(unmount,rump___sysimpl_unmount);
433 __weak_alias(_unmount,rump___sysimpl_unmount);
434 __strong_alias(_sys_unmount,rump___sysimpl_unmount);
435 #endif /* RUMP_KERNEL_IS_LIBC */
436 
437 int rump___sysimpl_setuid(uid_t);
438 int
439 rump___sysimpl_setuid(uid_t uid)
440 {
441 	register_t retval[2];
442 	int error = 0;
443 	int rv = -1;
444 	struct sys_setuid_args callarg;
445 
446 	memset(&callarg, 0, sizeof(callarg));
447 	SPARG(&callarg, uid) = uid;
448 
449 	error = rsys_syscall(SYS_setuid, &callarg, sizeof(callarg), retval);
450 	rsys_seterrno(error);
451 	if (error == 0) {
452 		if (sizeof(int) > sizeof(register_t))
453 			rv = *(int *)retval;
454 		else
455 			rv = *retval;
456 	}
457 	return rv;
458 }
459 #ifdef RUMP_KERNEL_IS_LIBC
460 __weak_alias(setuid,rump___sysimpl_setuid);
461 __weak_alias(_setuid,rump___sysimpl_setuid);
462 __strong_alias(_sys_setuid,rump___sysimpl_setuid);
463 #endif /* RUMP_KERNEL_IS_LIBC */
464 
465 uid_t rump___sysimpl_getuid(void);
466 uid_t
467 rump___sysimpl_getuid(void )
468 {
469 	register_t retval[2];
470 	uid_t rv = -1;
471 
472 	(void)rsys_syscall(SYS_getuid, NULL, 0, retval);
473 	if (sizeof(uid_t) > sizeof(register_t))
474 		rv = *(uid_t *)retval;
475 	else
476 		rv = *retval;
477 	return rv;
478 }
479 #ifdef RUMP_KERNEL_IS_LIBC
480 __weak_alias(getuid,rump___sysimpl_getuid);
481 __weak_alias(_getuid,rump___sysimpl_getuid);
482 __strong_alias(_sys_getuid,rump___sysimpl_getuid);
483 #endif /* RUMP_KERNEL_IS_LIBC */
484 
485 uid_t rump___sysimpl_geteuid(void);
486 uid_t
487 rump___sysimpl_geteuid(void )
488 {
489 	register_t retval[2];
490 	uid_t rv = -1;
491 
492 	(void)rsys_syscall(SYS_geteuid, NULL, 0, retval);
493 	if (sizeof(uid_t) > sizeof(register_t))
494 		rv = *(uid_t *)retval;
495 	else
496 		rv = *retval;
497 	return rv;
498 }
499 #ifdef RUMP_KERNEL_IS_LIBC
500 __weak_alias(geteuid,rump___sysimpl_geteuid);
501 __weak_alias(_geteuid,rump___sysimpl_geteuid);
502 __strong_alias(_sys_geteuid,rump___sysimpl_geteuid);
503 #endif /* RUMP_KERNEL_IS_LIBC */
504 
505 ssize_t rump___sysimpl_recvmsg(int, struct msghdr *, int);
506 ssize_t
507 rump___sysimpl_recvmsg(int s, struct msghdr * msg, int flags)
508 {
509 	register_t retval[2];
510 	int error = 0;
511 	ssize_t rv = -1;
512 	struct sys_recvmsg_args callarg;
513 
514 	memset(&callarg, 0, sizeof(callarg));
515 	SPARG(&callarg, s) = s;
516 	SPARG(&callarg, msg) = msg;
517 	SPARG(&callarg, flags) = flags;
518 
519 	error = rsys_syscall(SYS_recvmsg, &callarg, sizeof(callarg), retval);
520 	rsys_seterrno(error);
521 	if (error == 0) {
522 		if (sizeof(ssize_t) > sizeof(register_t))
523 			rv = *(ssize_t *)retval;
524 		else
525 			rv = *retval;
526 	}
527 	return rv;
528 }
529 #ifdef RUMP_KERNEL_IS_LIBC
530 __weak_alias(recvmsg,rump___sysimpl_recvmsg);
531 __weak_alias(_recvmsg,rump___sysimpl_recvmsg);
532 __strong_alias(_sys_recvmsg,rump___sysimpl_recvmsg);
533 #endif /* RUMP_KERNEL_IS_LIBC */
534 
535 ssize_t rump___sysimpl_sendmsg(int, const struct msghdr *, int);
536 ssize_t
537 rump___sysimpl_sendmsg(int s, const struct msghdr * msg, int flags)
538 {
539 	register_t retval[2];
540 	int error = 0;
541 	ssize_t rv = -1;
542 	struct sys_sendmsg_args callarg;
543 
544 	memset(&callarg, 0, sizeof(callarg));
545 	SPARG(&callarg, s) = s;
546 	SPARG(&callarg, msg) = msg;
547 	SPARG(&callarg, flags) = flags;
548 
549 	error = rsys_syscall(SYS_sendmsg, &callarg, sizeof(callarg), retval);
550 	rsys_seterrno(error);
551 	if (error == 0) {
552 		if (sizeof(ssize_t) > sizeof(register_t))
553 			rv = *(ssize_t *)retval;
554 		else
555 			rv = *retval;
556 	}
557 	return rv;
558 }
559 #ifdef RUMP_KERNEL_IS_LIBC
560 __weak_alias(sendmsg,rump___sysimpl_sendmsg);
561 __weak_alias(_sendmsg,rump___sysimpl_sendmsg);
562 __strong_alias(_sys_sendmsg,rump___sysimpl_sendmsg);
563 #endif /* RUMP_KERNEL_IS_LIBC */
564 
565 ssize_t rump___sysimpl_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
566 ssize_t
567 rump___sysimpl_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, socklen_t * fromlenaddr)
568 {
569 	register_t retval[2];
570 	int error = 0;
571 	ssize_t rv = -1;
572 	struct sys_recvfrom_args callarg;
573 
574 	memset(&callarg, 0, sizeof(callarg));
575 	SPARG(&callarg, s) = s;
576 	SPARG(&callarg, buf) = buf;
577 	SPARG(&callarg, len) = len;
578 	SPARG(&callarg, flags) = flags;
579 	SPARG(&callarg, from) = from;
580 	SPARG(&callarg, fromlenaddr) = fromlenaddr;
581 
582 	error = rsys_syscall(SYS_recvfrom, &callarg, sizeof(callarg), retval);
583 	rsys_seterrno(error);
584 	if (error == 0) {
585 		if (sizeof(ssize_t) > sizeof(register_t))
586 			rv = *(ssize_t *)retval;
587 		else
588 			rv = *retval;
589 	}
590 	return rv;
591 }
592 #ifdef RUMP_KERNEL_IS_LIBC
593 __weak_alias(recvfrom,rump___sysimpl_recvfrom);
594 __weak_alias(_recvfrom,rump___sysimpl_recvfrom);
595 __strong_alias(_sys_recvfrom,rump___sysimpl_recvfrom);
596 #endif /* RUMP_KERNEL_IS_LIBC */
597 
598 int rump___sysimpl_accept(int, struct sockaddr *, socklen_t *);
599 int
600 rump___sysimpl_accept(int s, struct sockaddr * name, socklen_t * anamelen)
601 {
602 	register_t retval[2];
603 	int error = 0;
604 	int rv = -1;
605 	struct sys_accept_args callarg;
606 
607 	memset(&callarg, 0, sizeof(callarg));
608 	SPARG(&callarg, s) = s;
609 	SPARG(&callarg, name) = name;
610 	SPARG(&callarg, anamelen) = anamelen;
611 
612 	error = rsys_syscall(SYS_accept, &callarg, sizeof(callarg), retval);
613 	rsys_seterrno(error);
614 	if (error == 0) {
615 		if (sizeof(int) > sizeof(register_t))
616 			rv = *(int *)retval;
617 		else
618 			rv = *retval;
619 	}
620 	return rv;
621 }
622 #ifdef RUMP_KERNEL_IS_LIBC
623 __weak_alias(accept,rump___sysimpl_accept);
624 __weak_alias(_accept,rump___sysimpl_accept);
625 __strong_alias(_sys_accept,rump___sysimpl_accept);
626 #endif /* RUMP_KERNEL_IS_LIBC */
627 
628 int rump___sysimpl_getpeername(int, struct sockaddr *, socklen_t *);
629 int
630 rump___sysimpl_getpeername(int fdes, struct sockaddr * asa, socklen_t * alen)
631 {
632 	register_t retval[2];
633 	int error = 0;
634 	int rv = -1;
635 	struct sys_getpeername_args callarg;
636 
637 	memset(&callarg, 0, sizeof(callarg));
638 	SPARG(&callarg, fdes) = fdes;
639 	SPARG(&callarg, asa) = asa;
640 	SPARG(&callarg, alen) = alen;
641 
642 	error = rsys_syscall(SYS_getpeername, &callarg, sizeof(callarg), retval);
643 	rsys_seterrno(error);
644 	if (error == 0) {
645 		if (sizeof(int) > sizeof(register_t))
646 			rv = *(int *)retval;
647 		else
648 			rv = *retval;
649 	}
650 	return rv;
651 }
652 #ifdef RUMP_KERNEL_IS_LIBC
653 __weak_alias(getpeername,rump___sysimpl_getpeername);
654 __weak_alias(_getpeername,rump___sysimpl_getpeername);
655 __strong_alias(_sys_getpeername,rump___sysimpl_getpeername);
656 #endif /* RUMP_KERNEL_IS_LIBC */
657 
658 int rump___sysimpl_getsockname(int, struct sockaddr *, socklen_t *);
659 int
660 rump___sysimpl_getsockname(int fdes, struct sockaddr * asa, socklen_t * alen)
661 {
662 	register_t retval[2];
663 	int error = 0;
664 	int rv = -1;
665 	struct sys_getsockname_args callarg;
666 
667 	memset(&callarg, 0, sizeof(callarg));
668 	SPARG(&callarg, fdes) = fdes;
669 	SPARG(&callarg, asa) = asa;
670 	SPARG(&callarg, alen) = alen;
671 
672 	error = rsys_syscall(SYS_getsockname, &callarg, sizeof(callarg), retval);
673 	rsys_seterrno(error);
674 	if (error == 0) {
675 		if (sizeof(int) > sizeof(register_t))
676 			rv = *(int *)retval;
677 		else
678 			rv = *retval;
679 	}
680 	return rv;
681 }
682 #ifdef RUMP_KERNEL_IS_LIBC
683 __weak_alias(getsockname,rump___sysimpl_getsockname);
684 __weak_alias(_getsockname,rump___sysimpl_getsockname);
685 __strong_alias(_sys_getsockname,rump___sysimpl_getsockname);
686 #endif /* RUMP_KERNEL_IS_LIBC */
687 
688 int rump___sysimpl_access(const char *, int);
689 int
690 rump___sysimpl_access(const char * path, int flags)
691 {
692 	register_t retval[2];
693 	int error = 0;
694 	int rv = -1;
695 	struct sys_access_args callarg;
696 
697 	memset(&callarg, 0, sizeof(callarg));
698 	SPARG(&callarg, path) = path;
699 	SPARG(&callarg, flags) = flags;
700 
701 	error = rsys_syscall(SYS_access, &callarg, sizeof(callarg), retval);
702 	rsys_seterrno(error);
703 	if (error == 0) {
704 		if (sizeof(int) > sizeof(register_t))
705 			rv = *(int *)retval;
706 		else
707 			rv = *retval;
708 	}
709 	return rv;
710 }
711 #ifdef RUMP_KERNEL_IS_LIBC
712 __weak_alias(access,rump___sysimpl_access);
713 __weak_alias(_access,rump___sysimpl_access);
714 __strong_alias(_sys_access,rump___sysimpl_access);
715 #endif /* RUMP_KERNEL_IS_LIBC */
716 
717 int rump___sysimpl_chflags(const char *, u_long);
718 int
719 rump___sysimpl_chflags(const char * path, u_long flags)
720 {
721 	register_t retval[2];
722 	int error = 0;
723 	int rv = -1;
724 	struct sys_chflags_args callarg;
725 
726 	memset(&callarg, 0, sizeof(callarg));
727 	SPARG(&callarg, path) = path;
728 	SPARG(&callarg, flags) = flags;
729 
730 	error = rsys_syscall(SYS_chflags, &callarg, sizeof(callarg), retval);
731 	rsys_seterrno(error);
732 	if (error == 0) {
733 		if (sizeof(int) > sizeof(register_t))
734 			rv = *(int *)retval;
735 		else
736 			rv = *retval;
737 	}
738 	return rv;
739 }
740 #ifdef RUMP_KERNEL_IS_LIBC
741 __weak_alias(chflags,rump___sysimpl_chflags);
742 __weak_alias(_chflags,rump___sysimpl_chflags);
743 __strong_alias(_sys_chflags,rump___sysimpl_chflags);
744 #endif /* RUMP_KERNEL_IS_LIBC */
745 
746 int rump___sysimpl_fchflags(int, u_long);
747 int
748 rump___sysimpl_fchflags(int fd, u_long flags)
749 {
750 	register_t retval[2];
751 	int error = 0;
752 	int rv = -1;
753 	struct sys_fchflags_args callarg;
754 
755 	memset(&callarg, 0, sizeof(callarg));
756 	SPARG(&callarg, fd) = fd;
757 	SPARG(&callarg, flags) = flags;
758 
759 	error = rsys_syscall(SYS_fchflags, &callarg, sizeof(callarg), retval);
760 	rsys_seterrno(error);
761 	if (error == 0) {
762 		if (sizeof(int) > sizeof(register_t))
763 			rv = *(int *)retval;
764 		else
765 			rv = *retval;
766 	}
767 	return rv;
768 }
769 #ifdef RUMP_KERNEL_IS_LIBC
770 __weak_alias(fchflags,rump___sysimpl_fchflags);
771 __weak_alias(_fchflags,rump___sysimpl_fchflags);
772 __strong_alias(_sys_fchflags,rump___sysimpl_fchflags);
773 #endif /* RUMP_KERNEL_IS_LIBC */
774 
775 void rump___sysimpl_sync(void);
776 void
777 rump___sysimpl_sync(void )
778 {
779 	register_t retval[2];
780 
781 	rsys_syscall(SYS_sync, NULL, 0, retval);
782 }
783 #ifdef RUMP_KERNEL_IS_LIBC
784 __weak_alias(sync,rump___sysimpl_sync);
785 __weak_alias(_sync,rump___sysimpl_sync);
786 __strong_alias(_sys_sync,rump___sysimpl_sync);
787 #endif /* RUMP_KERNEL_IS_LIBC */
788 
789 pid_t rump___sysimpl_getppid(void);
790 pid_t
791 rump___sysimpl_getppid(void )
792 {
793 	register_t retval[2];
794 	pid_t rv = -1;
795 
796 	(void)rsys_syscall(SYS_getppid, NULL, 0, retval);
797 	if (sizeof(pid_t) > sizeof(register_t))
798 		rv = *(pid_t *)retval;
799 	else
800 		rv = *retval;
801 	return rv;
802 }
803 #ifdef RUMP_KERNEL_IS_LIBC
804 __weak_alias(getppid,rump___sysimpl_getppid);
805 __weak_alias(_getppid,rump___sysimpl_getppid);
806 __strong_alias(_sys_getppid,rump___sysimpl_getppid);
807 #endif /* RUMP_KERNEL_IS_LIBC */
808 
809 int rump___sysimpl_dup(int);
810 int
811 rump___sysimpl_dup(int fd)
812 {
813 	register_t retval[2];
814 	int error = 0;
815 	int rv = -1;
816 	struct sys_dup_args callarg;
817 
818 	memset(&callarg, 0, sizeof(callarg));
819 	SPARG(&callarg, fd) = fd;
820 
821 	error = rsys_syscall(SYS_dup, &callarg, sizeof(callarg), retval);
822 	rsys_seterrno(error);
823 	if (error == 0) {
824 		if (sizeof(int) > sizeof(register_t))
825 			rv = *(int *)retval;
826 		else
827 			rv = *retval;
828 	}
829 	return rv;
830 }
831 #ifdef RUMP_KERNEL_IS_LIBC
832 __weak_alias(dup,rump___sysimpl_dup);
833 __weak_alias(_dup,rump___sysimpl_dup);
834 __strong_alias(_sys_dup,rump___sysimpl_dup);
835 #endif /* RUMP_KERNEL_IS_LIBC */
836 
837 gid_t rump___sysimpl_getegid(void);
838 gid_t
839 rump___sysimpl_getegid(void )
840 {
841 	register_t retval[2];
842 	gid_t rv = -1;
843 
844 	(void)rsys_syscall(SYS_getegid, NULL, 0, retval);
845 	if (sizeof(gid_t) > sizeof(register_t))
846 		rv = *(gid_t *)retval;
847 	else
848 		rv = *retval;
849 	return rv;
850 }
851 #ifdef RUMP_KERNEL_IS_LIBC
852 __weak_alias(getegid,rump___sysimpl_getegid);
853 __weak_alias(_getegid,rump___sysimpl_getegid);
854 __strong_alias(_sys_getegid,rump___sysimpl_getegid);
855 #endif /* RUMP_KERNEL_IS_LIBC */
856 
857 int rump___sysimpl_ktrace(const char *, int, int, pid_t);
858 int
859 rump___sysimpl_ktrace(const char * fname, int ops, int facs, pid_t pid)
860 {
861 	register_t retval[2];
862 	int error = 0;
863 	int rv = -1;
864 	struct sys_ktrace_args callarg;
865 
866 	memset(&callarg, 0, sizeof(callarg));
867 	SPARG(&callarg, fname) = fname;
868 	SPARG(&callarg, ops) = ops;
869 	SPARG(&callarg, facs) = facs;
870 	SPARG(&callarg, pid) = pid;
871 
872 	error = rsys_syscall(SYS_ktrace, &callarg, sizeof(callarg), retval);
873 	rsys_seterrno(error);
874 	if (error == 0) {
875 		if (sizeof(int) > sizeof(register_t))
876 			rv = *(int *)retval;
877 		else
878 			rv = *retval;
879 	}
880 	return rv;
881 }
882 #ifdef RUMP_KERNEL_IS_LIBC
883 __weak_alias(ktrace,rump___sysimpl_ktrace);
884 __weak_alias(_ktrace,rump___sysimpl_ktrace);
885 __strong_alias(_sys_ktrace,rump___sysimpl_ktrace);
886 #endif /* RUMP_KERNEL_IS_LIBC */
887 
888 gid_t rump___sysimpl_getgid(void);
889 gid_t
890 rump___sysimpl_getgid(void )
891 {
892 	register_t retval[2];
893 	gid_t rv = -1;
894 
895 	(void)rsys_syscall(SYS_getgid, NULL, 0, retval);
896 	if (sizeof(gid_t) > sizeof(register_t))
897 		rv = *(gid_t *)retval;
898 	else
899 		rv = *retval;
900 	return rv;
901 }
902 #ifdef RUMP_KERNEL_IS_LIBC
903 __weak_alias(getgid,rump___sysimpl_getgid);
904 __weak_alias(_getgid,rump___sysimpl_getgid);
905 __strong_alias(_sys_getgid,rump___sysimpl_getgid);
906 #endif /* RUMP_KERNEL_IS_LIBC */
907 
908 int rump___sysimpl___getlogin(char *, size_t);
909 int
910 rump___sysimpl___getlogin(char * namebuf, size_t namelen)
911 {
912 	register_t retval[2];
913 	int error = 0;
914 	int rv = -1;
915 	struct sys___getlogin_args callarg;
916 
917 	memset(&callarg, 0, sizeof(callarg));
918 	SPARG(&callarg, namebuf) = namebuf;
919 	SPARG(&callarg, namelen) = namelen;
920 
921 	error = rsys_syscall(SYS___getlogin, &callarg, sizeof(callarg), retval);
922 	rsys_seterrno(error);
923 	if (error == 0) {
924 		if (sizeof(int) > sizeof(register_t))
925 			rv = *(int *)retval;
926 		else
927 			rv = *retval;
928 	}
929 	return rv;
930 }
931 #ifdef RUMP_KERNEL_IS_LIBC
932 __weak_alias(__getlogin,rump___sysimpl___getlogin);
933 __weak_alias(___getlogin,rump___sysimpl___getlogin);
934 __strong_alias(_sys___getlogin,rump___sysimpl___getlogin);
935 #endif /* RUMP_KERNEL_IS_LIBC */
936 
937 int rump___sysimpl___setlogin(const char *);
938 int
939 rump___sysimpl___setlogin(const char * namebuf)
940 {
941 	register_t retval[2];
942 	int error = 0;
943 	int rv = -1;
944 	struct sys___setlogin_args callarg;
945 
946 	memset(&callarg, 0, sizeof(callarg));
947 	SPARG(&callarg, namebuf) = namebuf;
948 
949 	error = rsys_syscall(SYS___setlogin, &callarg, sizeof(callarg), retval);
950 	rsys_seterrno(error);
951 	if (error == 0) {
952 		if (sizeof(int) > sizeof(register_t))
953 			rv = *(int *)retval;
954 		else
955 			rv = *retval;
956 	}
957 	return rv;
958 }
959 #ifdef RUMP_KERNEL_IS_LIBC
960 __weak_alias(__setlogin,rump___sysimpl___setlogin);
961 __weak_alias(___setlogin,rump___sysimpl___setlogin);
962 __strong_alias(_sys___setlogin,rump___sysimpl___setlogin);
963 #endif /* RUMP_KERNEL_IS_LIBC */
964 
965 int rump___sysimpl_ioctl(int, u_long, void *);
966 int
967 rump___sysimpl_ioctl(int fd, u_long com, void * data)
968 {
969 	register_t retval[2];
970 	int error = 0;
971 	int rv = -1;
972 	struct sys_ioctl_args callarg;
973 
974 	memset(&callarg, 0, sizeof(callarg));
975 	SPARG(&callarg, fd) = fd;
976 	SPARG(&callarg, com) = com;
977 	SPARG(&callarg, data) = data;
978 
979 	error = rsys_syscall(SYS_ioctl, &callarg, sizeof(callarg), retval);
980 	rsys_seterrno(error);
981 	if (error == 0) {
982 		if (sizeof(int) > sizeof(register_t))
983 			rv = *(int *)retval;
984 		else
985 			rv = *retval;
986 	}
987 	return rv;
988 }
989 #ifdef RUMP_KERNEL_IS_LIBC
990 __weak_alias(ioctl,rump___sysimpl_ioctl);
991 __weak_alias(_ioctl,rump___sysimpl_ioctl);
992 __strong_alias(_sys_ioctl,rump___sysimpl_ioctl);
993 #endif /* RUMP_KERNEL_IS_LIBC */
994 
995 int rump___sysimpl_revoke(const char *);
996 int
997 rump___sysimpl_revoke(const char * path)
998 {
999 	register_t retval[2];
1000 	int error = 0;
1001 	int rv = -1;
1002 	struct sys_revoke_args callarg;
1003 
1004 	memset(&callarg, 0, sizeof(callarg));
1005 	SPARG(&callarg, path) = path;
1006 
1007 	error = rsys_syscall(SYS_revoke, &callarg, sizeof(callarg), retval);
1008 	rsys_seterrno(error);
1009 	if (error == 0) {
1010 		if (sizeof(int) > sizeof(register_t))
1011 			rv = *(int *)retval;
1012 		else
1013 			rv = *retval;
1014 	}
1015 	return rv;
1016 }
1017 #ifdef RUMP_KERNEL_IS_LIBC
1018 __weak_alias(revoke,rump___sysimpl_revoke);
1019 __weak_alias(_revoke,rump___sysimpl_revoke);
1020 __strong_alias(_sys_revoke,rump___sysimpl_revoke);
1021 #endif /* RUMP_KERNEL_IS_LIBC */
1022 
1023 int rump___sysimpl_symlink(const char *, const char *);
1024 int
1025 rump___sysimpl_symlink(const char * path, const char * link)
1026 {
1027 	register_t retval[2];
1028 	int error = 0;
1029 	int rv = -1;
1030 	struct sys_symlink_args callarg;
1031 
1032 	memset(&callarg, 0, sizeof(callarg));
1033 	SPARG(&callarg, path) = path;
1034 	SPARG(&callarg, link) = link;
1035 
1036 	error = rsys_syscall(SYS_symlink, &callarg, sizeof(callarg), retval);
1037 	rsys_seterrno(error);
1038 	if (error == 0) {
1039 		if (sizeof(int) > sizeof(register_t))
1040 			rv = *(int *)retval;
1041 		else
1042 			rv = *retval;
1043 	}
1044 	return rv;
1045 }
1046 #ifdef RUMP_KERNEL_IS_LIBC
1047 __weak_alias(symlink,rump___sysimpl_symlink);
1048 __weak_alias(_symlink,rump___sysimpl_symlink);
1049 __strong_alias(_sys_symlink,rump___sysimpl_symlink);
1050 #endif /* RUMP_KERNEL_IS_LIBC */
1051 
1052 ssize_t rump___sysimpl_readlink(const char *, char *, size_t);
1053 ssize_t
1054 rump___sysimpl_readlink(const char * path, char * buf, size_t count)
1055 {
1056 	register_t retval[2];
1057 	int error = 0;
1058 	ssize_t rv = -1;
1059 	struct sys_readlink_args callarg;
1060 
1061 	memset(&callarg, 0, sizeof(callarg));
1062 	SPARG(&callarg, path) = path;
1063 	SPARG(&callarg, buf) = buf;
1064 	SPARG(&callarg, count) = count;
1065 
1066 	error = rsys_syscall(SYS_readlink, &callarg, sizeof(callarg), retval);
1067 	rsys_seterrno(error);
1068 	if (error == 0) {
1069 		if (sizeof(ssize_t) > sizeof(register_t))
1070 			rv = *(ssize_t *)retval;
1071 		else
1072 			rv = *retval;
1073 	}
1074 	return rv;
1075 }
1076 #ifdef RUMP_KERNEL_IS_LIBC
1077 __weak_alias(readlink,rump___sysimpl_readlink);
1078 __weak_alias(_readlink,rump___sysimpl_readlink);
1079 __strong_alias(_sys_readlink,rump___sysimpl_readlink);
1080 #endif /* RUMP_KERNEL_IS_LIBC */
1081 
1082 mode_t rump___sysimpl_umask(mode_t);
1083 mode_t
1084 rump___sysimpl_umask(mode_t newmask)
1085 {
1086 	register_t retval[2];
1087 	int error = 0;
1088 	mode_t rv = -1;
1089 	struct sys_umask_args callarg;
1090 
1091 	memset(&callarg, 0, sizeof(callarg));
1092 	SPARG(&callarg, newmask) = newmask;
1093 
1094 	error = rsys_syscall(SYS_umask, &callarg, sizeof(callarg), retval);
1095 	rsys_seterrno(error);
1096 	if (error == 0) {
1097 		if (sizeof(mode_t) > sizeof(register_t))
1098 			rv = *(mode_t *)retval;
1099 		else
1100 			rv = *retval;
1101 	}
1102 	return rv;
1103 }
1104 #ifdef RUMP_KERNEL_IS_LIBC
1105 __weak_alias(umask,rump___sysimpl_umask);
1106 __weak_alias(_umask,rump___sysimpl_umask);
1107 __strong_alias(_sys_umask,rump___sysimpl_umask);
1108 #endif /* RUMP_KERNEL_IS_LIBC */
1109 
1110 int rump___sysimpl_chroot(const char *);
1111 int
1112 rump___sysimpl_chroot(const char * path)
1113 {
1114 	register_t retval[2];
1115 	int error = 0;
1116 	int rv = -1;
1117 	struct sys_chroot_args callarg;
1118 
1119 	memset(&callarg, 0, sizeof(callarg));
1120 	SPARG(&callarg, path) = path;
1121 
1122 	error = rsys_syscall(SYS_chroot, &callarg, sizeof(callarg), retval);
1123 	rsys_seterrno(error);
1124 	if (error == 0) {
1125 		if (sizeof(int) > sizeof(register_t))
1126 			rv = *(int *)retval;
1127 		else
1128 			rv = *retval;
1129 	}
1130 	return rv;
1131 }
1132 #ifdef RUMP_KERNEL_IS_LIBC
1133 __weak_alias(chroot,rump___sysimpl_chroot);
1134 __weak_alias(_chroot,rump___sysimpl_chroot);
1135 __strong_alias(_sys_chroot,rump___sysimpl_chroot);
1136 #endif /* RUMP_KERNEL_IS_LIBC */
1137 
1138 int rump___sysimpl_getgroups(int, gid_t *);
1139 int
1140 rump___sysimpl_getgroups(int gidsetsize, gid_t * gidset)
1141 {
1142 	register_t retval[2];
1143 	int error = 0;
1144 	int rv = -1;
1145 	struct sys_getgroups_args callarg;
1146 
1147 	memset(&callarg, 0, sizeof(callarg));
1148 	SPARG(&callarg, gidsetsize) = gidsetsize;
1149 	SPARG(&callarg, gidset) = gidset;
1150 
1151 	error = rsys_syscall(SYS_getgroups, &callarg, sizeof(callarg), retval);
1152 	rsys_seterrno(error);
1153 	if (error == 0) {
1154 		if (sizeof(int) > sizeof(register_t))
1155 			rv = *(int *)retval;
1156 		else
1157 			rv = *retval;
1158 	}
1159 	return rv;
1160 }
1161 #ifdef RUMP_KERNEL_IS_LIBC
1162 __weak_alias(getgroups,rump___sysimpl_getgroups);
1163 __weak_alias(_getgroups,rump___sysimpl_getgroups);
1164 __strong_alias(_sys_getgroups,rump___sysimpl_getgroups);
1165 #endif /* RUMP_KERNEL_IS_LIBC */
1166 
1167 int rump___sysimpl_setgroups(int, const gid_t *);
1168 int
1169 rump___sysimpl_setgroups(int gidsetsize, const gid_t * gidset)
1170 {
1171 	register_t retval[2];
1172 	int error = 0;
1173 	int rv = -1;
1174 	struct sys_setgroups_args callarg;
1175 
1176 	memset(&callarg, 0, sizeof(callarg));
1177 	SPARG(&callarg, gidsetsize) = gidsetsize;
1178 	SPARG(&callarg, gidset) = gidset;
1179 
1180 	error = rsys_syscall(SYS_setgroups, &callarg, sizeof(callarg), retval);
1181 	rsys_seterrno(error);
1182 	if (error == 0) {
1183 		if (sizeof(int) > sizeof(register_t))
1184 			rv = *(int *)retval;
1185 		else
1186 			rv = *retval;
1187 	}
1188 	return rv;
1189 }
1190 #ifdef RUMP_KERNEL_IS_LIBC
1191 __weak_alias(setgroups,rump___sysimpl_setgroups);
1192 __weak_alias(_setgroups,rump___sysimpl_setgroups);
1193 __strong_alias(_sys_setgroups,rump___sysimpl_setgroups);
1194 #endif /* RUMP_KERNEL_IS_LIBC */
1195 
1196 int rump___sysimpl_getpgrp(void);
1197 int
1198 rump___sysimpl_getpgrp(void )
1199 {
1200 	register_t retval[2];
1201 	int error = 0;
1202 	int rv = -1;
1203 
1204 	error = rsys_syscall(SYS_getpgrp, NULL, 0, retval);
1205 	rsys_seterrno(error);
1206 	if (error == 0) {
1207 		if (sizeof(int) > sizeof(register_t))
1208 			rv = *(int *)retval;
1209 		else
1210 			rv = *retval;
1211 	}
1212 	return rv;
1213 }
1214 #ifdef RUMP_KERNEL_IS_LIBC
1215 __weak_alias(getpgrp,rump___sysimpl_getpgrp);
1216 __weak_alias(_getpgrp,rump___sysimpl_getpgrp);
1217 __strong_alias(_sys_getpgrp,rump___sysimpl_getpgrp);
1218 #endif /* RUMP_KERNEL_IS_LIBC */
1219 
1220 int rump___sysimpl_setpgid(pid_t, pid_t);
1221 int
1222 rump___sysimpl_setpgid(pid_t pid, pid_t pgid)
1223 {
1224 	register_t retval[2];
1225 	int error = 0;
1226 	int rv = -1;
1227 	struct sys_setpgid_args callarg;
1228 
1229 	memset(&callarg, 0, sizeof(callarg));
1230 	SPARG(&callarg, pid) = pid;
1231 	SPARG(&callarg, pgid) = pgid;
1232 
1233 	error = rsys_syscall(SYS_setpgid, &callarg, sizeof(callarg), retval);
1234 	rsys_seterrno(error);
1235 	if (error == 0) {
1236 		if (sizeof(int) > sizeof(register_t))
1237 			rv = *(int *)retval;
1238 		else
1239 			rv = *retval;
1240 	}
1241 	return rv;
1242 }
1243 #ifdef RUMP_KERNEL_IS_LIBC
1244 __weak_alias(setpgid,rump___sysimpl_setpgid);
1245 __weak_alias(_setpgid,rump___sysimpl_setpgid);
1246 __strong_alias(_sys_setpgid,rump___sysimpl_setpgid);
1247 #endif /* RUMP_KERNEL_IS_LIBC */
1248 
1249 int rump___sysimpl_dup2(int, int);
1250 int
1251 rump___sysimpl_dup2(int from, int to)
1252 {
1253 	register_t retval[2];
1254 	int error = 0;
1255 	int rv = -1;
1256 	struct sys_dup2_args callarg;
1257 
1258 	memset(&callarg, 0, sizeof(callarg));
1259 	SPARG(&callarg, from) = from;
1260 	SPARG(&callarg, to) = to;
1261 
1262 	error = rsys_syscall(SYS_dup2, &callarg, sizeof(callarg), retval);
1263 	rsys_seterrno(error);
1264 	if (error == 0) {
1265 		if (sizeof(int) > sizeof(register_t))
1266 			rv = *(int *)retval;
1267 		else
1268 			rv = *retval;
1269 	}
1270 	return rv;
1271 }
1272 #ifdef RUMP_KERNEL_IS_LIBC
1273 __weak_alias(dup2,rump___sysimpl_dup2);
1274 __weak_alias(_dup2,rump___sysimpl_dup2);
1275 __strong_alias(_sys_dup2,rump___sysimpl_dup2);
1276 #endif /* RUMP_KERNEL_IS_LIBC */
1277 
1278 ssize_t rump___sysimpl_getrandom(void *, size_t, unsigned int);
1279 ssize_t
1280 rump___sysimpl_getrandom(void * buf, size_t buflen, unsigned int flags)
1281 {
1282 	register_t retval[2];
1283 	int error = 0;
1284 	ssize_t rv = -1;
1285 	struct sys_getrandom_args callarg;
1286 
1287 	memset(&callarg, 0, sizeof(callarg));
1288 	SPARG(&callarg, buf) = buf;
1289 	SPARG(&callarg, buflen) = buflen;
1290 	SPARG(&callarg, flags) = flags;
1291 
1292 	error = rsys_syscall(SYS_getrandom, &callarg, sizeof(callarg), retval);
1293 	rsys_seterrno(error);
1294 	if (error == 0) {
1295 		if (sizeof(ssize_t) > sizeof(register_t))
1296 			rv = *(ssize_t *)retval;
1297 		else
1298 			rv = *retval;
1299 	}
1300 	return rv;
1301 }
1302 #ifdef RUMP_KERNEL_IS_LIBC
1303 __weak_alias(getrandom,rump___sysimpl_getrandom);
1304 __weak_alias(_getrandom,rump___sysimpl_getrandom);
1305 __strong_alias(_sys_getrandom,rump___sysimpl_getrandom);
1306 #endif /* RUMP_KERNEL_IS_LIBC */
1307 
1308 int rump___sysimpl_fcntl(int, int, void *);
1309 int
1310 rump___sysimpl_fcntl(int fd, int cmd, void * arg)
1311 {
1312 	register_t retval[2];
1313 	int error = 0;
1314 	int rv = -1;
1315 	struct sys_fcntl_args callarg;
1316 
1317 	memset(&callarg, 0, sizeof(callarg));
1318 	SPARG(&callarg, fd) = fd;
1319 	SPARG(&callarg, cmd) = cmd;
1320 	SPARG(&callarg, arg) = arg;
1321 
1322 	error = rsys_syscall(SYS_fcntl, &callarg, sizeof(callarg), retval);
1323 	rsys_seterrno(error);
1324 	if (error == 0) {
1325 		if (sizeof(int) > sizeof(register_t))
1326 			rv = *(int *)retval;
1327 		else
1328 			rv = *retval;
1329 	}
1330 	return rv;
1331 }
1332 #ifdef RUMP_KERNEL_IS_LIBC
1333 __weak_alias(fcntl,rump___sysimpl_fcntl);
1334 __weak_alias(_fcntl,rump___sysimpl_fcntl);
1335 __strong_alias(_sys_fcntl,rump___sysimpl_fcntl);
1336 #endif /* RUMP_KERNEL_IS_LIBC */
1337 
1338 #ifdef RUMP_SYS_COMPAT
1339 int rump___sysimpl_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
1340 int
1341 rump___sysimpl_select(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv)
1342 {
1343 	register_t retval[2];
1344 	int error = 0;
1345 	int rv = -1;
1346 	struct compat_50_sys_select_args callarg;
1347 
1348 	memset(&callarg, 0, sizeof(callarg));
1349 	SPARG(&callarg, nd) = nd;
1350 	SPARG(&callarg, in) = in;
1351 	SPARG(&callarg, ou) = ou;
1352 	SPARG(&callarg, ex) = ex;
1353 	SPARG(&callarg, tv) = (struct timeval50 *)tv;
1354 
1355 	error = rsys_syscall(SYS_compat_50_select, &callarg, sizeof(callarg), retval);
1356 	rsys_seterrno(error);
1357 	if (error == 0) {
1358 		if (sizeof(int) > sizeof(register_t))
1359 			rv = *(int *)retval;
1360 		else
1361 			rv = *retval;
1362 	}
1363 	return rv;
1364 }
1365 #ifdef RUMP_KERNEL_IS_LIBC
1366 __weak_alias(select,rump___sysimpl_select);
1367 __weak_alias(_select,rump___sysimpl_select);
1368 __strong_alias(_sys_select,rump___sysimpl_select);
1369 #endif /* RUMP_KERNEL_IS_LIBC */
1370 #endif /* RUMP_SYS_COMPAT */
1371 
1372 int rump___sysimpl_fsync(int);
1373 int
1374 rump___sysimpl_fsync(int fd)
1375 {
1376 	register_t retval[2];
1377 	int error = 0;
1378 	int rv = -1;
1379 	struct sys_fsync_args callarg;
1380 
1381 	memset(&callarg, 0, sizeof(callarg));
1382 	SPARG(&callarg, fd) = fd;
1383 
1384 	error = rsys_syscall(SYS_fsync, &callarg, sizeof(callarg), retval);
1385 	rsys_seterrno(error);
1386 	if (error == 0) {
1387 		if (sizeof(int) > sizeof(register_t))
1388 			rv = *(int *)retval;
1389 		else
1390 			rv = *retval;
1391 	}
1392 	return rv;
1393 }
1394 #ifdef RUMP_KERNEL_IS_LIBC
1395 __weak_alias(fsync,rump___sysimpl_fsync);
1396 __weak_alias(_fsync,rump___sysimpl_fsync);
1397 __strong_alias(_sys_fsync,rump___sysimpl_fsync);
1398 #endif /* RUMP_KERNEL_IS_LIBC */
1399 
1400 int rump___sysimpl_connect(int, const struct sockaddr *, socklen_t);
1401 int
1402 rump___sysimpl_connect(int s, const struct sockaddr * name, socklen_t namelen)
1403 {
1404 	register_t retval[2];
1405 	int error = 0;
1406 	int rv = -1;
1407 	struct sys_connect_args callarg;
1408 
1409 	memset(&callarg, 0, sizeof(callarg));
1410 	SPARG(&callarg, s) = s;
1411 	SPARG(&callarg, name) = name;
1412 	SPARG(&callarg, namelen) = namelen;
1413 
1414 	error = rsys_syscall(SYS_connect, &callarg, sizeof(callarg), retval);
1415 	rsys_seterrno(error);
1416 	if (error == 0) {
1417 		if (sizeof(int) > sizeof(register_t))
1418 			rv = *(int *)retval;
1419 		else
1420 			rv = *retval;
1421 	}
1422 	return rv;
1423 }
1424 #ifdef RUMP_KERNEL_IS_LIBC
1425 __weak_alias(connect,rump___sysimpl_connect);
1426 __weak_alias(_connect,rump___sysimpl_connect);
1427 __strong_alias(_sys_connect,rump___sysimpl_connect);
1428 #endif /* RUMP_KERNEL_IS_LIBC */
1429 
1430 int rump___sysimpl_bind(int, const struct sockaddr *, socklen_t);
1431 int
1432 rump___sysimpl_bind(int s, const struct sockaddr * name, socklen_t namelen)
1433 {
1434 	register_t retval[2];
1435 	int error = 0;
1436 	int rv = -1;
1437 	struct sys_bind_args callarg;
1438 
1439 	memset(&callarg, 0, sizeof(callarg));
1440 	SPARG(&callarg, s) = s;
1441 	SPARG(&callarg, name) = name;
1442 	SPARG(&callarg, namelen) = namelen;
1443 
1444 	error = rsys_syscall(SYS_bind, &callarg, sizeof(callarg), retval);
1445 	rsys_seterrno(error);
1446 	if (error == 0) {
1447 		if (sizeof(int) > sizeof(register_t))
1448 			rv = *(int *)retval;
1449 		else
1450 			rv = *retval;
1451 	}
1452 	return rv;
1453 }
1454 #ifdef RUMP_KERNEL_IS_LIBC
1455 __weak_alias(bind,rump___sysimpl_bind);
1456 __weak_alias(_bind,rump___sysimpl_bind);
1457 __strong_alias(_sys_bind,rump___sysimpl_bind);
1458 #endif /* RUMP_KERNEL_IS_LIBC */
1459 
1460 int rump___sysimpl_setsockopt(int, int, int, const void *, socklen_t);
1461 int
1462 rump___sysimpl_setsockopt(int s, int level, int name, const void * val, socklen_t valsize)
1463 {
1464 	register_t retval[2];
1465 	int error = 0;
1466 	int rv = -1;
1467 	struct sys_setsockopt_args callarg;
1468 
1469 	memset(&callarg, 0, sizeof(callarg));
1470 	SPARG(&callarg, s) = s;
1471 	SPARG(&callarg, level) = level;
1472 	SPARG(&callarg, name) = name;
1473 	SPARG(&callarg, val) = val;
1474 	SPARG(&callarg, valsize) = valsize;
1475 
1476 	error = rsys_syscall(SYS_setsockopt, &callarg, sizeof(callarg), retval);
1477 	rsys_seterrno(error);
1478 	if (error == 0) {
1479 		if (sizeof(int) > sizeof(register_t))
1480 			rv = *(int *)retval;
1481 		else
1482 			rv = *retval;
1483 	}
1484 	return rv;
1485 }
1486 #ifdef RUMP_KERNEL_IS_LIBC
1487 __weak_alias(setsockopt,rump___sysimpl_setsockopt);
1488 __weak_alias(_setsockopt,rump___sysimpl_setsockopt);
1489 __strong_alias(_sys_setsockopt,rump___sysimpl_setsockopt);
1490 #endif /* RUMP_KERNEL_IS_LIBC */
1491 
1492 int rump___sysimpl_listen(int, int);
1493 int
1494 rump___sysimpl_listen(int s, int backlog)
1495 {
1496 	register_t retval[2];
1497 	int error = 0;
1498 	int rv = -1;
1499 	struct sys_listen_args callarg;
1500 
1501 	memset(&callarg, 0, sizeof(callarg));
1502 	SPARG(&callarg, s) = s;
1503 	SPARG(&callarg, backlog) = backlog;
1504 
1505 	error = rsys_syscall(SYS_listen, &callarg, sizeof(callarg), retval);
1506 	rsys_seterrno(error);
1507 	if (error == 0) {
1508 		if (sizeof(int) > sizeof(register_t))
1509 			rv = *(int *)retval;
1510 		else
1511 			rv = *retval;
1512 	}
1513 	return rv;
1514 }
1515 #ifdef RUMP_KERNEL_IS_LIBC
1516 __weak_alias(listen,rump___sysimpl_listen);
1517 __weak_alias(_listen,rump___sysimpl_listen);
1518 __strong_alias(_sys_listen,rump___sysimpl_listen);
1519 #endif /* RUMP_KERNEL_IS_LIBC */
1520 
1521 int rump___sysimpl_getsockopt(int, int, int, void *, socklen_t *);
1522 int
1523 rump___sysimpl_getsockopt(int s, int level, int name, void * val, socklen_t * avalsize)
1524 {
1525 	register_t retval[2];
1526 	int error = 0;
1527 	int rv = -1;
1528 	struct sys_getsockopt_args callarg;
1529 
1530 	memset(&callarg, 0, sizeof(callarg));
1531 	SPARG(&callarg, s) = s;
1532 	SPARG(&callarg, level) = level;
1533 	SPARG(&callarg, name) = name;
1534 	SPARG(&callarg, val) = val;
1535 	SPARG(&callarg, avalsize) = avalsize;
1536 
1537 	error = rsys_syscall(SYS_getsockopt, &callarg, sizeof(callarg), retval);
1538 	rsys_seterrno(error);
1539 	if (error == 0) {
1540 		if (sizeof(int) > sizeof(register_t))
1541 			rv = *(int *)retval;
1542 		else
1543 			rv = *retval;
1544 	}
1545 	return rv;
1546 }
1547 #ifdef RUMP_KERNEL_IS_LIBC
1548 __weak_alias(getsockopt,rump___sysimpl_getsockopt);
1549 __weak_alias(_getsockopt,rump___sysimpl_getsockopt);
1550 __strong_alias(_sys_getsockopt,rump___sysimpl_getsockopt);
1551 #endif /* RUMP_KERNEL_IS_LIBC */
1552 
1553 ssize_t rump___sysimpl_readv(int, const struct iovec *, int);
1554 ssize_t
1555 rump___sysimpl_readv(int fd, const struct iovec * iovp, int iovcnt)
1556 {
1557 	register_t retval[2];
1558 	int error = 0;
1559 	ssize_t rv = -1;
1560 	struct sys_readv_args callarg;
1561 
1562 	memset(&callarg, 0, sizeof(callarg));
1563 	SPARG(&callarg, fd) = fd;
1564 	SPARG(&callarg, iovp) = iovp;
1565 	SPARG(&callarg, iovcnt) = iovcnt;
1566 
1567 	error = rsys_syscall(SYS_readv, &callarg, sizeof(callarg), retval);
1568 	rsys_seterrno(error);
1569 	if (error == 0) {
1570 		if (sizeof(ssize_t) > sizeof(register_t))
1571 			rv = *(ssize_t *)retval;
1572 		else
1573 			rv = *retval;
1574 	}
1575 	return rv;
1576 }
1577 #ifdef RUMP_KERNEL_IS_LIBC
1578 __weak_alias(readv,rump___sysimpl_readv);
1579 __weak_alias(_readv,rump___sysimpl_readv);
1580 __strong_alias(_sys_readv,rump___sysimpl_readv);
1581 #endif /* RUMP_KERNEL_IS_LIBC */
1582 
1583 ssize_t rump___sysimpl_writev(int, const struct iovec *, int);
1584 ssize_t
1585 rump___sysimpl_writev(int fd, const struct iovec * iovp, int iovcnt)
1586 {
1587 	register_t retval[2];
1588 	int error = 0;
1589 	ssize_t rv = -1;
1590 	struct sys_writev_args callarg;
1591 
1592 	memset(&callarg, 0, sizeof(callarg));
1593 	SPARG(&callarg, fd) = fd;
1594 	SPARG(&callarg, iovp) = iovp;
1595 	SPARG(&callarg, iovcnt) = iovcnt;
1596 
1597 	error = rsys_syscall(SYS_writev, &callarg, sizeof(callarg), retval);
1598 	rsys_seterrno(error);
1599 	if (error == 0) {
1600 		if (sizeof(ssize_t) > sizeof(register_t))
1601 			rv = *(ssize_t *)retval;
1602 		else
1603 			rv = *retval;
1604 	}
1605 	return rv;
1606 }
1607 #ifdef RUMP_KERNEL_IS_LIBC
1608 __weak_alias(writev,rump___sysimpl_writev);
1609 __weak_alias(_writev,rump___sysimpl_writev);
1610 __strong_alias(_sys_writev,rump___sysimpl_writev);
1611 #endif /* RUMP_KERNEL_IS_LIBC */
1612 
1613 int rump___sysimpl_fchown(int, uid_t, gid_t);
1614 int
1615 rump___sysimpl_fchown(int fd, uid_t uid, gid_t gid)
1616 {
1617 	register_t retval[2];
1618 	int error = 0;
1619 	int rv = -1;
1620 	struct sys_fchown_args callarg;
1621 
1622 	memset(&callarg, 0, sizeof(callarg));
1623 	SPARG(&callarg, fd) = fd;
1624 	SPARG(&callarg, uid) = uid;
1625 	SPARG(&callarg, gid) = gid;
1626 
1627 	error = rsys_syscall(SYS_fchown, &callarg, sizeof(callarg), retval);
1628 	rsys_seterrno(error);
1629 	if (error == 0) {
1630 		if (sizeof(int) > sizeof(register_t))
1631 			rv = *(int *)retval;
1632 		else
1633 			rv = *retval;
1634 	}
1635 	return rv;
1636 }
1637 #ifdef RUMP_KERNEL_IS_LIBC
1638 __weak_alias(fchown,rump___sysimpl_fchown);
1639 __weak_alias(_fchown,rump___sysimpl_fchown);
1640 __strong_alias(_sys_fchown,rump___sysimpl_fchown);
1641 #endif /* RUMP_KERNEL_IS_LIBC */
1642 
1643 int rump___sysimpl_fchmod(int, mode_t);
1644 int
1645 rump___sysimpl_fchmod(int fd, mode_t mode)
1646 {
1647 	register_t retval[2];
1648 	int error = 0;
1649 	int rv = -1;
1650 	struct sys_fchmod_args callarg;
1651 
1652 	memset(&callarg, 0, sizeof(callarg));
1653 	SPARG(&callarg, fd) = fd;
1654 	SPARG(&callarg, mode) = mode;
1655 
1656 	error = rsys_syscall(SYS_fchmod, &callarg, sizeof(callarg), retval);
1657 	rsys_seterrno(error);
1658 	if (error == 0) {
1659 		if (sizeof(int) > sizeof(register_t))
1660 			rv = *(int *)retval;
1661 		else
1662 			rv = *retval;
1663 	}
1664 	return rv;
1665 }
1666 #ifdef RUMP_KERNEL_IS_LIBC
1667 __weak_alias(fchmod,rump___sysimpl_fchmod);
1668 __weak_alias(_fchmod,rump___sysimpl_fchmod);
1669 __strong_alias(_sys_fchmod,rump___sysimpl_fchmod);
1670 #endif /* RUMP_KERNEL_IS_LIBC */
1671 
1672 int rump___sysimpl_setreuid(uid_t, uid_t);
1673 int
1674 rump___sysimpl_setreuid(uid_t ruid, uid_t euid)
1675 {
1676 	register_t retval[2];
1677 	int error = 0;
1678 	int rv = -1;
1679 	struct sys_setreuid_args callarg;
1680 
1681 	memset(&callarg, 0, sizeof(callarg));
1682 	SPARG(&callarg, ruid) = ruid;
1683 	SPARG(&callarg, euid) = euid;
1684 
1685 	error = rsys_syscall(SYS_setreuid, &callarg, sizeof(callarg), retval);
1686 	rsys_seterrno(error);
1687 	if (error == 0) {
1688 		if (sizeof(int) > sizeof(register_t))
1689 			rv = *(int *)retval;
1690 		else
1691 			rv = *retval;
1692 	}
1693 	return rv;
1694 }
1695 #ifdef RUMP_KERNEL_IS_LIBC
1696 __weak_alias(setreuid,rump___sysimpl_setreuid);
1697 __weak_alias(_setreuid,rump___sysimpl_setreuid);
1698 __strong_alias(_sys_setreuid,rump___sysimpl_setreuid);
1699 #endif /* RUMP_KERNEL_IS_LIBC */
1700 
1701 int rump___sysimpl_setregid(gid_t, gid_t);
1702 int
1703 rump___sysimpl_setregid(gid_t rgid, gid_t egid)
1704 {
1705 	register_t retval[2];
1706 	int error = 0;
1707 	int rv = -1;
1708 	struct sys_setregid_args callarg;
1709 
1710 	memset(&callarg, 0, sizeof(callarg));
1711 	SPARG(&callarg, rgid) = rgid;
1712 	SPARG(&callarg, egid) = egid;
1713 
1714 	error = rsys_syscall(SYS_setregid, &callarg, sizeof(callarg), retval);
1715 	rsys_seterrno(error);
1716 	if (error == 0) {
1717 		if (sizeof(int) > sizeof(register_t))
1718 			rv = *(int *)retval;
1719 		else
1720 			rv = *retval;
1721 	}
1722 	return rv;
1723 }
1724 #ifdef RUMP_KERNEL_IS_LIBC
1725 __weak_alias(setregid,rump___sysimpl_setregid);
1726 __weak_alias(_setregid,rump___sysimpl_setregid);
1727 __strong_alias(_sys_setregid,rump___sysimpl_setregid);
1728 #endif /* RUMP_KERNEL_IS_LIBC */
1729 
1730 int rump___sysimpl_rename(const char *, const char *);
1731 int
1732 rump___sysimpl_rename(const char * from, const char * to)
1733 {
1734 	register_t retval[2];
1735 	int error = 0;
1736 	int rv = -1;
1737 	struct sys_rename_args callarg;
1738 
1739 	memset(&callarg, 0, sizeof(callarg));
1740 	SPARG(&callarg, from) = from;
1741 	SPARG(&callarg, to) = to;
1742 
1743 	error = rsys_syscall(SYS_rename, &callarg, sizeof(callarg), retval);
1744 	rsys_seterrno(error);
1745 	if (error == 0) {
1746 		if (sizeof(int) > sizeof(register_t))
1747 			rv = *(int *)retval;
1748 		else
1749 			rv = *retval;
1750 	}
1751 	return rv;
1752 }
1753 #ifdef RUMP_KERNEL_IS_LIBC
1754 __weak_alias(rename,rump___sysimpl_rename);
1755 __weak_alias(_rename,rump___sysimpl_rename);
1756 __strong_alias(_sys_rename,rump___sysimpl_rename);
1757 #endif /* RUMP_KERNEL_IS_LIBC */
1758 
1759 int rump___sysimpl_flock(int, int);
1760 int
1761 rump___sysimpl_flock(int fd, int how)
1762 {
1763 	register_t retval[2];
1764 	int error = 0;
1765 	int rv = -1;
1766 	struct sys_flock_args callarg;
1767 
1768 	memset(&callarg, 0, sizeof(callarg));
1769 	SPARG(&callarg, fd) = fd;
1770 	SPARG(&callarg, how) = how;
1771 
1772 	error = rsys_syscall(SYS_flock, &callarg, sizeof(callarg), retval);
1773 	rsys_seterrno(error);
1774 	if (error == 0) {
1775 		if (sizeof(int) > sizeof(register_t))
1776 			rv = *(int *)retval;
1777 		else
1778 			rv = *retval;
1779 	}
1780 	return rv;
1781 }
1782 #ifdef RUMP_KERNEL_IS_LIBC
1783 __weak_alias(flock,rump___sysimpl_flock);
1784 __weak_alias(_flock,rump___sysimpl_flock);
1785 __strong_alias(_sys_flock,rump___sysimpl_flock);
1786 #endif /* RUMP_KERNEL_IS_LIBC */
1787 
1788 int rump___sysimpl_mkfifo(const char *, mode_t);
1789 int
1790 rump___sysimpl_mkfifo(const char * path, mode_t mode)
1791 {
1792 	register_t retval[2];
1793 	int error = 0;
1794 	int rv = -1;
1795 	struct sys_mkfifo_args callarg;
1796 
1797 	memset(&callarg, 0, sizeof(callarg));
1798 	SPARG(&callarg, path) = path;
1799 	SPARG(&callarg, mode) = mode;
1800 
1801 	error = rsys_syscall(SYS_mkfifo, &callarg, sizeof(callarg), retval);
1802 	rsys_seterrno(error);
1803 	if (error == 0) {
1804 		if (sizeof(int) > sizeof(register_t))
1805 			rv = *(int *)retval;
1806 		else
1807 			rv = *retval;
1808 	}
1809 	return rv;
1810 }
1811 #ifdef RUMP_KERNEL_IS_LIBC
1812 __weak_alias(mkfifo,rump___sysimpl_mkfifo);
1813 __weak_alias(_mkfifo,rump___sysimpl_mkfifo);
1814 __strong_alias(_sys_mkfifo,rump___sysimpl_mkfifo);
1815 #endif /* RUMP_KERNEL_IS_LIBC */
1816 
1817 ssize_t rump___sysimpl_sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t);
1818 ssize_t
1819 rump___sysimpl_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, socklen_t tolen)
1820 {
1821 	register_t retval[2];
1822 	int error = 0;
1823 	ssize_t rv = -1;
1824 	struct sys_sendto_args callarg;
1825 
1826 	memset(&callarg, 0, sizeof(callarg));
1827 	SPARG(&callarg, s) = s;
1828 	SPARG(&callarg, buf) = buf;
1829 	SPARG(&callarg, len) = len;
1830 	SPARG(&callarg, flags) = flags;
1831 	SPARG(&callarg, to) = to;
1832 	SPARG(&callarg, tolen) = tolen;
1833 
1834 	error = rsys_syscall(SYS_sendto, &callarg, sizeof(callarg), retval);
1835 	rsys_seterrno(error);
1836 	if (error == 0) {
1837 		if (sizeof(ssize_t) > sizeof(register_t))
1838 			rv = *(ssize_t *)retval;
1839 		else
1840 			rv = *retval;
1841 	}
1842 	return rv;
1843 }
1844 #ifdef RUMP_KERNEL_IS_LIBC
1845 __weak_alias(sendto,rump___sysimpl_sendto);
1846 __weak_alias(_sendto,rump___sysimpl_sendto);
1847 __strong_alias(_sys_sendto,rump___sysimpl_sendto);
1848 #endif /* RUMP_KERNEL_IS_LIBC */
1849 
1850 int rump___sysimpl_shutdown(int, int);
1851 int
1852 rump___sysimpl_shutdown(int s, int how)
1853 {
1854 	register_t retval[2];
1855 	int error = 0;
1856 	int rv = -1;
1857 	struct sys_shutdown_args callarg;
1858 
1859 	memset(&callarg, 0, sizeof(callarg));
1860 	SPARG(&callarg, s) = s;
1861 	SPARG(&callarg, how) = how;
1862 
1863 	error = rsys_syscall(SYS_shutdown, &callarg, sizeof(callarg), retval);
1864 	rsys_seterrno(error);
1865 	if (error == 0) {
1866 		if (sizeof(int) > sizeof(register_t))
1867 			rv = *(int *)retval;
1868 		else
1869 			rv = *retval;
1870 	}
1871 	return rv;
1872 }
1873 #ifdef RUMP_KERNEL_IS_LIBC
1874 __weak_alias(shutdown,rump___sysimpl_shutdown);
1875 __weak_alias(_shutdown,rump___sysimpl_shutdown);
1876 __strong_alias(_sys_shutdown,rump___sysimpl_shutdown);
1877 #endif /* RUMP_KERNEL_IS_LIBC */
1878 
1879 int rump___sysimpl_socketpair(int, int, int, int *);
1880 int
1881 rump___sysimpl_socketpair(int domain, int type, int protocol, int * rsv)
1882 {
1883 	register_t retval[2];
1884 	int error = 0;
1885 	int rv = -1;
1886 	struct sys_socketpair_args callarg;
1887 
1888 	memset(&callarg, 0, sizeof(callarg));
1889 	SPARG(&callarg, domain) = domain;
1890 	SPARG(&callarg, type) = type;
1891 	SPARG(&callarg, protocol) = protocol;
1892 	SPARG(&callarg, rsv) = rsv;
1893 
1894 	error = rsys_syscall(SYS_socketpair, &callarg, sizeof(callarg), retval);
1895 	rsys_seterrno(error);
1896 	if (error == 0) {
1897 		if (sizeof(int) > sizeof(register_t))
1898 			rv = *(int *)retval;
1899 		else
1900 			rv = *retval;
1901 	}
1902 	return rv;
1903 }
1904 #ifdef RUMP_KERNEL_IS_LIBC
1905 __weak_alias(socketpair,rump___sysimpl_socketpair);
1906 __weak_alias(_socketpair,rump___sysimpl_socketpair);
1907 __strong_alias(_sys_socketpair,rump___sysimpl_socketpair);
1908 #endif /* RUMP_KERNEL_IS_LIBC */
1909 
1910 int rump___sysimpl_mkdir(const char *, mode_t);
1911 int
1912 rump___sysimpl_mkdir(const char * path, mode_t mode)
1913 {
1914 	register_t retval[2];
1915 	int error = 0;
1916 	int rv = -1;
1917 	struct sys_mkdir_args callarg;
1918 
1919 	memset(&callarg, 0, sizeof(callarg));
1920 	SPARG(&callarg, path) = path;
1921 	SPARG(&callarg, mode) = mode;
1922 
1923 	error = rsys_syscall(SYS_mkdir, &callarg, sizeof(callarg), retval);
1924 	rsys_seterrno(error);
1925 	if (error == 0) {
1926 		if (sizeof(int) > sizeof(register_t))
1927 			rv = *(int *)retval;
1928 		else
1929 			rv = *retval;
1930 	}
1931 	return rv;
1932 }
1933 #ifdef RUMP_KERNEL_IS_LIBC
1934 __weak_alias(mkdir,rump___sysimpl_mkdir);
1935 __weak_alias(_mkdir,rump___sysimpl_mkdir);
1936 __strong_alias(_sys_mkdir,rump___sysimpl_mkdir);
1937 #endif /* RUMP_KERNEL_IS_LIBC */
1938 
1939 int rump___sysimpl_rmdir(const char *);
1940 int
1941 rump___sysimpl_rmdir(const char * path)
1942 {
1943 	register_t retval[2];
1944 	int error = 0;
1945 	int rv = -1;
1946 	struct sys_rmdir_args callarg;
1947 
1948 	memset(&callarg, 0, sizeof(callarg));
1949 	SPARG(&callarg, path) = path;
1950 
1951 	error = rsys_syscall(SYS_rmdir, &callarg, sizeof(callarg), retval);
1952 	rsys_seterrno(error);
1953 	if (error == 0) {
1954 		if (sizeof(int) > sizeof(register_t))
1955 			rv = *(int *)retval;
1956 		else
1957 			rv = *retval;
1958 	}
1959 	return rv;
1960 }
1961 #ifdef RUMP_KERNEL_IS_LIBC
1962 __weak_alias(rmdir,rump___sysimpl_rmdir);
1963 __weak_alias(_rmdir,rump___sysimpl_rmdir);
1964 __strong_alias(_sys_rmdir,rump___sysimpl_rmdir);
1965 #endif /* RUMP_KERNEL_IS_LIBC */
1966 
1967 #ifdef RUMP_SYS_COMPAT
1968 int rump___sysimpl_utimes(const char *, const struct timeval *);
1969 int
1970 rump___sysimpl_utimes(const char * path, const struct timeval * tptr)
1971 {
1972 	register_t retval[2];
1973 	int error = 0;
1974 	int rv = -1;
1975 	struct compat_50_sys_utimes_args callarg;
1976 
1977 	memset(&callarg, 0, sizeof(callarg));
1978 	SPARG(&callarg, path) = path;
1979 	SPARG(&callarg, tptr) = (const struct timeval50 *)tptr;
1980 
1981 	error = rsys_syscall(SYS_compat_50_utimes, &callarg, sizeof(callarg), retval);
1982 	rsys_seterrno(error);
1983 	if (error == 0) {
1984 		if (sizeof(int) > sizeof(register_t))
1985 			rv = *(int *)retval;
1986 		else
1987 			rv = *retval;
1988 	}
1989 	return rv;
1990 }
1991 #ifdef RUMP_KERNEL_IS_LIBC
1992 __weak_alias(utimes,rump___sysimpl_utimes);
1993 __weak_alias(_utimes,rump___sysimpl_utimes);
1994 __strong_alias(_sys_utimes,rump___sysimpl_utimes);
1995 #endif /* RUMP_KERNEL_IS_LIBC */
1996 #endif /* RUMP_SYS_COMPAT */
1997 
1998 int rump___sysimpl_setsid(void);
1999 int
2000 rump___sysimpl_setsid(void )
2001 {
2002 	register_t retval[2];
2003 	int error = 0;
2004 	int rv = -1;
2005 
2006 	error = rsys_syscall(SYS_setsid, NULL, 0, retval);
2007 	rsys_seterrno(error);
2008 	if (error == 0) {
2009 		if (sizeof(int) > sizeof(register_t))
2010 			rv = *(int *)retval;
2011 		else
2012 			rv = *retval;
2013 	}
2014 	return rv;
2015 }
2016 #ifdef RUMP_KERNEL_IS_LIBC
2017 __weak_alias(setsid,rump___sysimpl_setsid);
2018 __weak_alias(_setsid,rump___sysimpl_setsid);
2019 __strong_alias(_sys_setsid,rump___sysimpl_setsid);
2020 #endif /* RUMP_KERNEL_IS_LIBC */
2021 
2022 int rump___sysimpl_nfssvc(int, void *);
2023 int
2024 rump___sysimpl_nfssvc(int flag, void * argp)
2025 {
2026 	register_t retval[2];
2027 	int error = 0;
2028 	int rv = -1;
2029 	struct sys_nfssvc_args callarg;
2030 
2031 	memset(&callarg, 0, sizeof(callarg));
2032 	SPARG(&callarg, flag) = flag;
2033 	SPARG(&callarg, argp) = argp;
2034 
2035 	error = rsys_syscall(SYS_nfssvc, &callarg, sizeof(callarg), retval);
2036 	rsys_seterrno(error);
2037 	if (error == 0) {
2038 		if (sizeof(int) > sizeof(register_t))
2039 			rv = *(int *)retval;
2040 		else
2041 			rv = *retval;
2042 	}
2043 	return rv;
2044 }
2045 #ifdef RUMP_KERNEL_IS_LIBC
2046 __weak_alias(nfssvc,rump___sysimpl_nfssvc);
2047 __weak_alias(_nfssvc,rump___sysimpl_nfssvc);
2048 __strong_alias(_sys_nfssvc,rump___sysimpl_nfssvc);
2049 #endif /* RUMP_KERNEL_IS_LIBC */
2050 
2051 ssize_t rump___sysimpl_pread(int, void *, size_t, off_t);
2052 ssize_t
2053 rump___sysimpl_pread(int fd, void * buf, size_t nbyte, off_t offset)
2054 {
2055 	register_t retval[2];
2056 	int error = 0;
2057 	ssize_t rv = -1;
2058 	struct sys_pread_args callarg;
2059 
2060 	memset(&callarg, 0, sizeof(callarg));
2061 	SPARG(&callarg, fd) = fd;
2062 	SPARG(&callarg, buf) = buf;
2063 	SPARG(&callarg, nbyte) = nbyte;
2064 	SPARG(&callarg, PAD) = 0;
2065 	SPARG(&callarg, offset) = offset;
2066 
2067 	error = rsys_syscall(SYS_pread, &callarg, sizeof(callarg), retval);
2068 	rsys_seterrno(error);
2069 	if (error == 0) {
2070 		if (sizeof(ssize_t) > sizeof(register_t))
2071 			rv = *(ssize_t *)retval;
2072 		else
2073 			rv = *retval;
2074 	}
2075 	return rv;
2076 }
2077 #ifdef RUMP_KERNEL_IS_LIBC
2078 __weak_alias(pread,rump___sysimpl_pread);
2079 __weak_alias(_pread,rump___sysimpl_pread);
2080 __strong_alias(_sys_pread,rump___sysimpl_pread);
2081 #endif /* RUMP_KERNEL_IS_LIBC */
2082 
2083 ssize_t rump___sysimpl_pwrite(int, const void *, size_t, off_t);
2084 ssize_t
2085 rump___sysimpl_pwrite(int fd, const void * buf, size_t nbyte, off_t offset)
2086 {
2087 	register_t retval[2];
2088 	int error = 0;
2089 	ssize_t rv = -1;
2090 	struct sys_pwrite_args callarg;
2091 
2092 	memset(&callarg, 0, sizeof(callarg));
2093 	SPARG(&callarg, fd) = fd;
2094 	SPARG(&callarg, buf) = buf;
2095 	SPARG(&callarg, nbyte) = nbyte;
2096 	SPARG(&callarg, PAD) = 0;
2097 	SPARG(&callarg, offset) = offset;
2098 
2099 	error = rsys_syscall(SYS_pwrite, &callarg, sizeof(callarg), retval);
2100 	rsys_seterrno(error);
2101 	if (error == 0) {
2102 		if (sizeof(ssize_t) > sizeof(register_t))
2103 			rv = *(ssize_t *)retval;
2104 		else
2105 			rv = *retval;
2106 	}
2107 	return rv;
2108 }
2109 #ifdef RUMP_KERNEL_IS_LIBC
2110 __weak_alias(pwrite,rump___sysimpl_pwrite);
2111 __weak_alias(_pwrite,rump___sysimpl_pwrite);
2112 __strong_alias(_sys_pwrite,rump___sysimpl_pwrite);
2113 #endif /* RUMP_KERNEL_IS_LIBC */
2114 
2115 int rump___sysimpl_setgid(gid_t);
2116 int
2117 rump___sysimpl_setgid(gid_t gid)
2118 {
2119 	register_t retval[2];
2120 	int error = 0;
2121 	int rv = -1;
2122 	struct sys_setgid_args callarg;
2123 
2124 	memset(&callarg, 0, sizeof(callarg));
2125 	SPARG(&callarg, gid) = gid;
2126 
2127 	error = rsys_syscall(SYS_setgid, &callarg, sizeof(callarg), retval);
2128 	rsys_seterrno(error);
2129 	if (error == 0) {
2130 		if (sizeof(int) > sizeof(register_t))
2131 			rv = *(int *)retval;
2132 		else
2133 			rv = *retval;
2134 	}
2135 	return rv;
2136 }
2137 #ifdef RUMP_KERNEL_IS_LIBC
2138 __weak_alias(setgid,rump___sysimpl_setgid);
2139 __weak_alias(_setgid,rump___sysimpl_setgid);
2140 __strong_alias(_sys_setgid,rump___sysimpl_setgid);
2141 #endif /* RUMP_KERNEL_IS_LIBC */
2142 
2143 int rump___sysimpl_setegid(gid_t);
2144 int
2145 rump___sysimpl_setegid(gid_t egid)
2146 {
2147 	register_t retval[2];
2148 	int error = 0;
2149 	int rv = -1;
2150 	struct sys_setegid_args callarg;
2151 
2152 	memset(&callarg, 0, sizeof(callarg));
2153 	SPARG(&callarg, egid) = egid;
2154 
2155 	error = rsys_syscall(SYS_setegid, &callarg, sizeof(callarg), retval);
2156 	rsys_seterrno(error);
2157 	if (error == 0) {
2158 		if (sizeof(int) > sizeof(register_t))
2159 			rv = *(int *)retval;
2160 		else
2161 			rv = *retval;
2162 	}
2163 	return rv;
2164 }
2165 #ifdef RUMP_KERNEL_IS_LIBC
2166 __weak_alias(setegid,rump___sysimpl_setegid);
2167 __weak_alias(_setegid,rump___sysimpl_setegid);
2168 __strong_alias(_sys_setegid,rump___sysimpl_setegid);
2169 #endif /* RUMP_KERNEL_IS_LIBC */
2170 
2171 int rump___sysimpl_seteuid(uid_t);
2172 int
2173 rump___sysimpl_seteuid(uid_t euid)
2174 {
2175 	register_t retval[2];
2176 	int error = 0;
2177 	int rv = -1;
2178 	struct sys_seteuid_args callarg;
2179 
2180 	memset(&callarg, 0, sizeof(callarg));
2181 	SPARG(&callarg, euid) = euid;
2182 
2183 	error = rsys_syscall(SYS_seteuid, &callarg, sizeof(callarg), retval);
2184 	rsys_seterrno(error);
2185 	if (error == 0) {
2186 		if (sizeof(int) > sizeof(register_t))
2187 			rv = *(int *)retval;
2188 		else
2189 			rv = *retval;
2190 	}
2191 	return rv;
2192 }
2193 #ifdef RUMP_KERNEL_IS_LIBC
2194 __weak_alias(seteuid,rump___sysimpl_seteuid);
2195 __weak_alias(_seteuid,rump___sysimpl_seteuid);
2196 __strong_alias(_sys_seteuid,rump___sysimpl_seteuid);
2197 #endif /* RUMP_KERNEL_IS_LIBC */
2198 
2199 long rump___sysimpl_pathconf(const char *, int);
2200 long
2201 rump___sysimpl_pathconf(const char * path, int name)
2202 {
2203 	register_t retval[2];
2204 	int error = 0;
2205 	long rv = -1;
2206 	struct sys_pathconf_args callarg;
2207 
2208 	memset(&callarg, 0, sizeof(callarg));
2209 	SPARG(&callarg, path) = path;
2210 	SPARG(&callarg, name) = name;
2211 
2212 	error = rsys_syscall(SYS_pathconf, &callarg, sizeof(callarg), retval);
2213 	rsys_seterrno(error);
2214 	if (error == 0) {
2215 		if (sizeof(long) > sizeof(register_t))
2216 			rv = *(long *)retval;
2217 		else
2218 			rv = *retval;
2219 	}
2220 	return rv;
2221 }
2222 #ifdef RUMP_KERNEL_IS_LIBC
2223 __weak_alias(pathconf,rump___sysimpl_pathconf);
2224 __weak_alias(_pathconf,rump___sysimpl_pathconf);
2225 __strong_alias(_sys_pathconf,rump___sysimpl_pathconf);
2226 #endif /* RUMP_KERNEL_IS_LIBC */
2227 
2228 long rump___sysimpl_fpathconf(int, int);
2229 long
2230 rump___sysimpl_fpathconf(int fd, int name)
2231 {
2232 	register_t retval[2];
2233 	int error = 0;
2234 	long rv = -1;
2235 	struct sys_fpathconf_args callarg;
2236 
2237 	memset(&callarg, 0, sizeof(callarg));
2238 	SPARG(&callarg, fd) = fd;
2239 	SPARG(&callarg, name) = name;
2240 
2241 	error = rsys_syscall(SYS_fpathconf, &callarg, sizeof(callarg), retval);
2242 	rsys_seterrno(error);
2243 	if (error == 0) {
2244 		if (sizeof(long) > sizeof(register_t))
2245 			rv = *(long *)retval;
2246 		else
2247 			rv = *retval;
2248 	}
2249 	return rv;
2250 }
2251 #ifdef RUMP_KERNEL_IS_LIBC
2252 __weak_alias(fpathconf,rump___sysimpl_fpathconf);
2253 __weak_alias(_fpathconf,rump___sysimpl_fpathconf);
2254 __strong_alias(_sys_fpathconf,rump___sysimpl_fpathconf);
2255 #endif /* RUMP_KERNEL_IS_LIBC */
2256 
2257 int rump___sysimpl_getsockopt2(int, int, int, void *, socklen_t *);
2258 int
2259 rump___sysimpl_getsockopt2(int s, int level, int name, void * val, socklen_t * avalsize)
2260 {
2261 	register_t retval[2];
2262 	int error = 0;
2263 	int rv = -1;
2264 	struct sys_getsockopt2_args callarg;
2265 
2266 	memset(&callarg, 0, sizeof(callarg));
2267 	SPARG(&callarg, s) = s;
2268 	SPARG(&callarg, level) = level;
2269 	SPARG(&callarg, name) = name;
2270 	SPARG(&callarg, val) = val;
2271 	SPARG(&callarg, avalsize) = avalsize;
2272 
2273 	error = rsys_syscall(SYS_getsockopt2, &callarg, sizeof(callarg), retval);
2274 	rsys_seterrno(error);
2275 	if (error == 0) {
2276 		if (sizeof(int) > sizeof(register_t))
2277 			rv = *(int *)retval;
2278 		else
2279 			rv = *retval;
2280 	}
2281 	return rv;
2282 }
2283 #ifdef RUMP_KERNEL_IS_LIBC
2284 __weak_alias(getsockopt2,rump___sysimpl_getsockopt2);
2285 __weak_alias(_getsockopt2,rump___sysimpl_getsockopt2);
2286 __strong_alias(_sys_getsockopt2,rump___sysimpl_getsockopt2);
2287 #endif /* RUMP_KERNEL_IS_LIBC */
2288 
2289 int rump___sysimpl_getrlimit(int, struct rlimit *);
2290 int
2291 rump___sysimpl_getrlimit(int which, struct rlimit * rlp)
2292 {
2293 	register_t retval[2];
2294 	int error = 0;
2295 	int rv = -1;
2296 	struct sys_getrlimit_args callarg;
2297 
2298 	memset(&callarg, 0, sizeof(callarg));
2299 	SPARG(&callarg, which) = which;
2300 	SPARG(&callarg, rlp) = rlp;
2301 
2302 	error = rsys_syscall(SYS_getrlimit, &callarg, sizeof(callarg), retval);
2303 	rsys_seterrno(error);
2304 	if (error == 0) {
2305 		if (sizeof(int) > sizeof(register_t))
2306 			rv = *(int *)retval;
2307 		else
2308 			rv = *retval;
2309 	}
2310 	return rv;
2311 }
2312 #ifdef RUMP_KERNEL_IS_LIBC
2313 __weak_alias(getrlimit,rump___sysimpl_getrlimit);
2314 __weak_alias(_getrlimit,rump___sysimpl_getrlimit);
2315 __strong_alias(_sys_getrlimit,rump___sysimpl_getrlimit);
2316 #endif /* RUMP_KERNEL_IS_LIBC */
2317 
2318 int rump___sysimpl_setrlimit(int, const struct rlimit *);
2319 int
2320 rump___sysimpl_setrlimit(int which, const struct rlimit * rlp)
2321 {
2322 	register_t retval[2];
2323 	int error = 0;
2324 	int rv = -1;
2325 	struct sys_setrlimit_args callarg;
2326 
2327 	memset(&callarg, 0, sizeof(callarg));
2328 	SPARG(&callarg, which) = which;
2329 	SPARG(&callarg, rlp) = rlp;
2330 
2331 	error = rsys_syscall(SYS_setrlimit, &callarg, sizeof(callarg), retval);
2332 	rsys_seterrno(error);
2333 	if (error == 0) {
2334 		if (sizeof(int) > sizeof(register_t))
2335 			rv = *(int *)retval;
2336 		else
2337 			rv = *retval;
2338 	}
2339 	return rv;
2340 }
2341 #ifdef RUMP_KERNEL_IS_LIBC
2342 __weak_alias(setrlimit,rump___sysimpl_setrlimit);
2343 __weak_alias(_setrlimit,rump___sysimpl_setrlimit);
2344 __strong_alias(_sys_setrlimit,rump___sysimpl_setrlimit);
2345 #endif /* RUMP_KERNEL_IS_LIBC */
2346 
2347 off_t rump___sysimpl_lseek(int, off_t, int);
2348 off_t
2349 rump___sysimpl_lseek(int fd, off_t offset, int whence)
2350 {
2351 	register_t retval[2];
2352 	int error = 0;
2353 	off_t rv = -1;
2354 	struct sys_lseek_args callarg;
2355 
2356 	memset(&callarg, 0, sizeof(callarg));
2357 	SPARG(&callarg, fd) = fd;
2358 	SPARG(&callarg, PAD) = 0;
2359 	SPARG(&callarg, offset) = offset;
2360 	SPARG(&callarg, whence) = whence;
2361 
2362 	error = rsys_syscall(SYS_lseek, &callarg, sizeof(callarg), retval);
2363 	rsys_seterrno(error);
2364 	if (error == 0) {
2365 		if (sizeof(off_t) > sizeof(register_t))
2366 			rv = *(off_t *)retval;
2367 		else
2368 			rv = *retval;
2369 	}
2370 	return rv;
2371 }
2372 #ifdef RUMP_KERNEL_IS_LIBC
2373 __weak_alias(lseek,rump___sysimpl_lseek);
2374 __weak_alias(_lseek,rump___sysimpl_lseek);
2375 __strong_alias(_sys_lseek,rump___sysimpl_lseek);
2376 #endif /* RUMP_KERNEL_IS_LIBC */
2377 
2378 int rump___sysimpl_truncate(const char *, off_t);
2379 int
2380 rump___sysimpl_truncate(const char * path, off_t length)
2381 {
2382 	register_t retval[2];
2383 	int error = 0;
2384 	int rv = -1;
2385 	struct sys_truncate_args callarg;
2386 
2387 	memset(&callarg, 0, sizeof(callarg));
2388 	SPARG(&callarg, path) = path;
2389 	SPARG(&callarg, PAD) = 0;
2390 	SPARG(&callarg, length) = length;
2391 
2392 	error = rsys_syscall(SYS_truncate, &callarg, sizeof(callarg), retval);
2393 	rsys_seterrno(error);
2394 	if (error == 0) {
2395 		if (sizeof(int) > sizeof(register_t))
2396 			rv = *(int *)retval;
2397 		else
2398 			rv = *retval;
2399 	}
2400 	return rv;
2401 }
2402 #ifdef RUMP_KERNEL_IS_LIBC
2403 __weak_alias(truncate,rump___sysimpl_truncate);
2404 __weak_alias(_truncate,rump___sysimpl_truncate);
2405 __strong_alias(_sys_truncate,rump___sysimpl_truncate);
2406 #endif /* RUMP_KERNEL_IS_LIBC */
2407 
2408 int rump___sysimpl_ftruncate(int, off_t);
2409 int
2410 rump___sysimpl_ftruncate(int fd, off_t length)
2411 {
2412 	register_t retval[2];
2413 	int error = 0;
2414 	int rv = -1;
2415 	struct sys_ftruncate_args callarg;
2416 
2417 	memset(&callarg, 0, sizeof(callarg));
2418 	SPARG(&callarg, fd) = fd;
2419 	SPARG(&callarg, PAD) = 0;
2420 	SPARG(&callarg, length) = length;
2421 
2422 	error = rsys_syscall(SYS_ftruncate, &callarg, sizeof(callarg), retval);
2423 	rsys_seterrno(error);
2424 	if (error == 0) {
2425 		if (sizeof(int) > sizeof(register_t))
2426 			rv = *(int *)retval;
2427 		else
2428 			rv = *retval;
2429 	}
2430 	return rv;
2431 }
2432 #ifdef RUMP_KERNEL_IS_LIBC
2433 __weak_alias(ftruncate,rump___sysimpl_ftruncate);
2434 __weak_alias(_ftruncate,rump___sysimpl_ftruncate);
2435 __strong_alias(_sys_ftruncate,rump___sysimpl_ftruncate);
2436 #endif /* RUMP_KERNEL_IS_LIBC */
2437 
2438 int rump___sysimpl___sysctl(const int *, u_int, void *, size_t *, const void *, size_t);
2439 int
2440 rump___sysimpl___sysctl(const int * name, u_int namelen, void * oldv, size_t * oldlenp, const void * newv, size_t newlen)
2441 {
2442 	register_t retval[2];
2443 	int error = 0;
2444 	int rv = -1;
2445 	struct sys___sysctl_args callarg;
2446 
2447 	memset(&callarg, 0, sizeof(callarg));
2448 	SPARG(&callarg, name) = name;
2449 	SPARG(&callarg, namelen) = namelen;
2450 	SPARG(&callarg, oldv) = oldv;
2451 	SPARG(&callarg, oldlenp) = oldlenp;
2452 	SPARG(&callarg, newv) = newv;
2453 	SPARG(&callarg, newlen) = newlen;
2454 
2455 	error = rsys_syscall(SYS___sysctl, &callarg, sizeof(callarg), retval);
2456 	rsys_seterrno(error);
2457 	if (error == 0) {
2458 		if (sizeof(int) > sizeof(register_t))
2459 			rv = *(int *)retval;
2460 		else
2461 			rv = *retval;
2462 	}
2463 	return rv;
2464 }
2465 #ifdef RUMP_KERNEL_IS_LIBC
2466 __weak_alias(__sysctl,rump___sysimpl___sysctl);
2467 __weak_alias(___sysctl,rump___sysimpl___sysctl);
2468 __strong_alias(_sys___sysctl,rump___sysimpl___sysctl);
2469 #endif /* RUMP_KERNEL_IS_LIBC */
2470 
2471 #ifdef RUMP_SYS_COMPAT
2472 int rump___sysimpl_futimes(int, const struct timeval *);
2473 int
2474 rump___sysimpl_futimes(int fd, const struct timeval * tptr)
2475 {
2476 	register_t retval[2];
2477 	int error = 0;
2478 	int rv = -1;
2479 	struct compat_50_sys_futimes_args callarg;
2480 
2481 	memset(&callarg, 0, sizeof(callarg));
2482 	SPARG(&callarg, fd) = fd;
2483 	SPARG(&callarg, tptr) = (const struct timeval50 *)tptr;
2484 
2485 	error = rsys_syscall(SYS_compat_50_futimes, &callarg, sizeof(callarg), retval);
2486 	rsys_seterrno(error);
2487 	if (error == 0) {
2488 		if (sizeof(int) > sizeof(register_t))
2489 			rv = *(int *)retval;
2490 		else
2491 			rv = *retval;
2492 	}
2493 	return rv;
2494 }
2495 #ifdef RUMP_KERNEL_IS_LIBC
2496 __weak_alias(futimes,rump___sysimpl_futimes);
2497 __weak_alias(_futimes,rump___sysimpl_futimes);
2498 __strong_alias(_sys_futimes,rump___sysimpl_futimes);
2499 #endif /* RUMP_KERNEL_IS_LIBC */
2500 #endif /* RUMP_SYS_COMPAT */
2501 
2502 pid_t rump___sysimpl_getpgid(pid_t);
2503 pid_t
2504 rump___sysimpl_getpgid(pid_t pid)
2505 {
2506 	register_t retval[2];
2507 	int error = 0;
2508 	pid_t rv = -1;
2509 	struct sys_getpgid_args callarg;
2510 
2511 	memset(&callarg, 0, sizeof(callarg));
2512 	SPARG(&callarg, pid) = pid;
2513 
2514 	error = rsys_syscall(SYS_getpgid, &callarg, sizeof(callarg), retval);
2515 	rsys_seterrno(error);
2516 	if (error == 0) {
2517 		if (sizeof(pid_t) > sizeof(register_t))
2518 			rv = *(pid_t *)retval;
2519 		else
2520 			rv = *retval;
2521 	}
2522 	return rv;
2523 }
2524 #ifdef RUMP_KERNEL_IS_LIBC
2525 __weak_alias(getpgid,rump___sysimpl_getpgid);
2526 __weak_alias(_getpgid,rump___sysimpl_getpgid);
2527 __strong_alias(_sys_getpgid,rump___sysimpl_getpgid);
2528 #endif /* RUMP_KERNEL_IS_LIBC */
2529 
2530 int rump___sysimpl_reboot(int, char *);
2531 int
2532 rump___sysimpl_reboot(int opt, char * bootstr)
2533 {
2534 	register_t retval[2];
2535 	int error = 0;
2536 	int rv = -1;
2537 	struct sys_reboot_args callarg;
2538 
2539 	memset(&callarg, 0, sizeof(callarg));
2540 	SPARG(&callarg, opt) = opt;
2541 	SPARG(&callarg, bootstr) = bootstr;
2542 
2543 	error = rsys_syscall(SYS_reboot, &callarg, sizeof(callarg), retval);
2544 	rsys_seterrno(error);
2545 	if (error == 0) {
2546 		if (sizeof(int) > sizeof(register_t))
2547 			rv = *(int *)retval;
2548 		else
2549 			rv = *retval;
2550 	}
2551 	return rv;
2552 }
2553 #ifdef RUMP_KERNEL_IS_LIBC
2554 __weak_alias(reboot,rump___sysimpl_reboot);
2555 __weak_alias(_reboot,rump___sysimpl_reboot);
2556 __strong_alias(_sys_reboot,rump___sysimpl_reboot);
2557 #endif /* RUMP_KERNEL_IS_LIBC */
2558 
2559 int rump___sysimpl_poll(struct pollfd *, u_int, int);
2560 int
2561 rump___sysimpl_poll(struct pollfd * fds, u_int nfds, int timeout)
2562 {
2563 	register_t retval[2];
2564 	int error = 0;
2565 	int rv = -1;
2566 	struct sys_poll_args callarg;
2567 
2568 	memset(&callarg, 0, sizeof(callarg));
2569 	SPARG(&callarg, fds) = fds;
2570 	SPARG(&callarg, nfds) = nfds;
2571 	SPARG(&callarg, timeout) = timeout;
2572 
2573 	error = rsys_syscall(SYS_poll, &callarg, sizeof(callarg), retval);
2574 	rsys_seterrno(error);
2575 	if (error == 0) {
2576 		if (sizeof(int) > sizeof(register_t))
2577 			rv = *(int *)retval;
2578 		else
2579 			rv = *retval;
2580 	}
2581 	return rv;
2582 }
2583 #ifdef RUMP_KERNEL_IS_LIBC
2584 __weak_alias(poll,rump___sysimpl_poll);
2585 __weak_alias(_poll,rump___sysimpl_poll);
2586 __strong_alias(_sys_poll,rump___sysimpl_poll);
2587 #endif /* RUMP_KERNEL_IS_LIBC */
2588 
2589 int rump___sysimpl_timer_create(clockid_t, struct sigevent *, timer_t *);
2590 int
2591 rump___sysimpl_timer_create(clockid_t clock_id, struct sigevent * evp, timer_t * timerid)
2592 {
2593 	register_t retval[2];
2594 	int error = 0;
2595 	int rv = -1;
2596 	struct sys_timer_create_args callarg;
2597 
2598 	memset(&callarg, 0, sizeof(callarg));
2599 	SPARG(&callarg, clock_id) = clock_id;
2600 	SPARG(&callarg, evp) = evp;
2601 	SPARG(&callarg, timerid) = timerid;
2602 
2603 	error = rsys_syscall(SYS_timer_create, &callarg, sizeof(callarg), retval);
2604 	rsys_seterrno(error);
2605 	if (error == 0) {
2606 		if (sizeof(int) > sizeof(register_t))
2607 			rv = *(int *)retval;
2608 		else
2609 			rv = *retval;
2610 	}
2611 	return rv;
2612 }
2613 #ifdef RUMP_KERNEL_IS_LIBC
2614 __weak_alias(timer_create,rump___sysimpl_timer_create);
2615 __weak_alias(_timer_create,rump___sysimpl_timer_create);
2616 __strong_alias(_sys_timer_create,rump___sysimpl_timer_create);
2617 #endif /* RUMP_KERNEL_IS_LIBC */
2618 
2619 int rump___sysimpl_timer_delete(timer_t);
2620 int
2621 rump___sysimpl_timer_delete(timer_t timerid)
2622 {
2623 	register_t retval[2];
2624 	int error = 0;
2625 	int rv = -1;
2626 	struct sys_timer_delete_args callarg;
2627 
2628 	memset(&callarg, 0, sizeof(callarg));
2629 	SPARG(&callarg, timerid) = timerid;
2630 
2631 	error = rsys_syscall(SYS_timer_delete, &callarg, sizeof(callarg), retval);
2632 	rsys_seterrno(error);
2633 	if (error == 0) {
2634 		if (sizeof(int) > sizeof(register_t))
2635 			rv = *(int *)retval;
2636 		else
2637 			rv = *retval;
2638 	}
2639 	return rv;
2640 }
2641 #ifdef RUMP_KERNEL_IS_LIBC
2642 __weak_alias(timer_delete,rump___sysimpl_timer_delete);
2643 __weak_alias(_timer_delete,rump___sysimpl_timer_delete);
2644 __strong_alias(_sys_timer_delete,rump___sysimpl_timer_delete);
2645 #endif /* RUMP_KERNEL_IS_LIBC */
2646 
2647 int rump___sysimpl_timer_getoverrun(timer_t);
2648 int
2649 rump___sysimpl_timer_getoverrun(timer_t timerid)
2650 {
2651 	register_t retval[2];
2652 	int error = 0;
2653 	int rv = -1;
2654 	struct sys_timer_getoverrun_args callarg;
2655 
2656 	memset(&callarg, 0, sizeof(callarg));
2657 	SPARG(&callarg, timerid) = timerid;
2658 
2659 	error = rsys_syscall(SYS_timer_getoverrun, &callarg, sizeof(callarg), retval);
2660 	rsys_seterrno(error);
2661 	if (error == 0) {
2662 		if (sizeof(int) > sizeof(register_t))
2663 			rv = *(int *)retval;
2664 		else
2665 			rv = *retval;
2666 	}
2667 	return rv;
2668 }
2669 #ifdef RUMP_KERNEL_IS_LIBC
2670 __weak_alias(timer_getoverrun,rump___sysimpl_timer_getoverrun);
2671 __weak_alias(_timer_getoverrun,rump___sysimpl_timer_getoverrun);
2672 __strong_alias(_sys_timer_getoverrun,rump___sysimpl_timer_getoverrun);
2673 #endif /* RUMP_KERNEL_IS_LIBC */
2674 
2675 int rump___sysimpl_fdatasync(int);
2676 int
2677 rump___sysimpl_fdatasync(int fd)
2678 {
2679 	register_t retval[2];
2680 	int error = 0;
2681 	int rv = -1;
2682 	struct sys_fdatasync_args callarg;
2683 
2684 	memset(&callarg, 0, sizeof(callarg));
2685 	SPARG(&callarg, fd) = fd;
2686 
2687 	error = rsys_syscall(SYS_fdatasync, &callarg, sizeof(callarg), retval);
2688 	rsys_seterrno(error);
2689 	if (error == 0) {
2690 		if (sizeof(int) > sizeof(register_t))
2691 			rv = *(int *)retval;
2692 		else
2693 			rv = *retval;
2694 	}
2695 	return rv;
2696 }
2697 #ifdef RUMP_KERNEL_IS_LIBC
2698 __weak_alias(fdatasync,rump___sysimpl_fdatasync);
2699 __weak_alias(_fdatasync,rump___sysimpl_fdatasync);
2700 __strong_alias(_sys_fdatasync,rump___sysimpl_fdatasync);
2701 #endif /* RUMP_KERNEL_IS_LIBC */
2702 
2703 int rump___sysimpl_modctl(int, void *);
2704 int
2705 rump___sysimpl_modctl(int cmd, void * arg)
2706 {
2707 	register_t retval[2];
2708 	int error = 0;
2709 	int rv = -1;
2710 	struct sys_modctl_args callarg;
2711 
2712 	memset(&callarg, 0, sizeof(callarg));
2713 	SPARG(&callarg, cmd) = cmd;
2714 	SPARG(&callarg, arg) = arg;
2715 
2716 	error = rsys_syscall(SYS_modctl, &callarg, sizeof(callarg), retval);
2717 	rsys_seterrno(error);
2718 	if (error == 0) {
2719 		if (sizeof(int) > sizeof(register_t))
2720 			rv = *(int *)retval;
2721 		else
2722 			rv = *retval;
2723 	}
2724 	return rv;
2725 }
2726 #ifdef RUMP_KERNEL_IS_LIBC
2727 __weak_alias(modctl,rump___sysimpl_modctl);
2728 __weak_alias(_modctl,rump___sysimpl_modctl);
2729 __strong_alias(_sys_modctl,rump___sysimpl_modctl);
2730 #endif /* RUMP_KERNEL_IS_LIBC */
2731 
2732 int rump___sysimpl__ksem_init(unsigned int, intptr_t *);
2733 int
2734 rump___sysimpl__ksem_init(unsigned int value, intptr_t * idp)
2735 {
2736 	register_t retval[2];
2737 	int error = 0;
2738 	int rv = -1;
2739 	struct sys__ksem_init_args callarg;
2740 
2741 	memset(&callarg, 0, sizeof(callarg));
2742 	SPARG(&callarg, value) = value;
2743 	SPARG(&callarg, idp) = idp;
2744 
2745 	error = rsys_syscall(SYS__ksem_init, &callarg, sizeof(callarg), retval);
2746 	rsys_seterrno(error);
2747 	if (error == 0) {
2748 		if (sizeof(int) > sizeof(register_t))
2749 			rv = *(int *)retval;
2750 		else
2751 			rv = *retval;
2752 	}
2753 	return rv;
2754 }
2755 #ifdef RUMP_KERNEL_IS_LIBC
2756 __weak_alias(_ksem_init,rump___sysimpl__ksem_init);
2757 __weak_alias(__ksem_init,rump___sysimpl__ksem_init);
2758 __strong_alias(_sys__ksem_init,rump___sysimpl__ksem_init);
2759 #endif /* RUMP_KERNEL_IS_LIBC */
2760 
2761 int rump___sysimpl__ksem_open(const char *, int, mode_t, unsigned int, intptr_t *);
2762 int
2763 rump___sysimpl__ksem_open(const char * name, int oflag, mode_t mode, unsigned int value, intptr_t * idp)
2764 {
2765 	register_t retval[2];
2766 	int error = 0;
2767 	int rv = -1;
2768 	struct sys__ksem_open_args callarg;
2769 
2770 	memset(&callarg, 0, sizeof(callarg));
2771 	SPARG(&callarg, name) = name;
2772 	SPARG(&callarg, oflag) = oflag;
2773 	SPARG(&callarg, mode) = mode;
2774 	SPARG(&callarg, value) = value;
2775 	SPARG(&callarg, idp) = idp;
2776 
2777 	error = rsys_syscall(SYS__ksem_open, &callarg, sizeof(callarg), retval);
2778 	rsys_seterrno(error);
2779 	if (error == 0) {
2780 		if (sizeof(int) > sizeof(register_t))
2781 			rv = *(int *)retval;
2782 		else
2783 			rv = *retval;
2784 	}
2785 	return rv;
2786 }
2787 #ifdef RUMP_KERNEL_IS_LIBC
2788 __weak_alias(_ksem_open,rump___sysimpl__ksem_open);
2789 __weak_alias(__ksem_open,rump___sysimpl__ksem_open);
2790 __strong_alias(_sys__ksem_open,rump___sysimpl__ksem_open);
2791 #endif /* RUMP_KERNEL_IS_LIBC */
2792 
2793 int rump___sysimpl__ksem_unlink(const char *);
2794 int
2795 rump___sysimpl__ksem_unlink(const char * name)
2796 {
2797 	register_t retval[2];
2798 	int error = 0;
2799 	int rv = -1;
2800 	struct sys__ksem_unlink_args callarg;
2801 
2802 	memset(&callarg, 0, sizeof(callarg));
2803 	SPARG(&callarg, name) = name;
2804 
2805 	error = rsys_syscall(SYS__ksem_unlink, &callarg, sizeof(callarg), retval);
2806 	rsys_seterrno(error);
2807 	if (error == 0) {
2808 		if (sizeof(int) > sizeof(register_t))
2809 			rv = *(int *)retval;
2810 		else
2811 			rv = *retval;
2812 	}
2813 	return rv;
2814 }
2815 #ifdef RUMP_KERNEL_IS_LIBC
2816 __weak_alias(_ksem_unlink,rump___sysimpl__ksem_unlink);
2817 __weak_alias(__ksem_unlink,rump___sysimpl__ksem_unlink);
2818 __strong_alias(_sys__ksem_unlink,rump___sysimpl__ksem_unlink);
2819 #endif /* RUMP_KERNEL_IS_LIBC */
2820 
2821 int rump___sysimpl__ksem_close(intptr_t);
2822 int
2823 rump___sysimpl__ksem_close(intptr_t id)
2824 {
2825 	register_t retval[2];
2826 	int error = 0;
2827 	int rv = -1;
2828 	struct sys__ksem_close_args callarg;
2829 
2830 	memset(&callarg, 0, sizeof(callarg));
2831 	SPARG(&callarg, id) = id;
2832 
2833 	error = rsys_syscall(SYS__ksem_close, &callarg, sizeof(callarg), retval);
2834 	rsys_seterrno(error);
2835 	if (error == 0) {
2836 		if (sizeof(int) > sizeof(register_t))
2837 			rv = *(int *)retval;
2838 		else
2839 			rv = *retval;
2840 	}
2841 	return rv;
2842 }
2843 #ifdef RUMP_KERNEL_IS_LIBC
2844 __weak_alias(_ksem_close,rump___sysimpl__ksem_close);
2845 __weak_alias(__ksem_close,rump___sysimpl__ksem_close);
2846 __strong_alias(_sys__ksem_close,rump___sysimpl__ksem_close);
2847 #endif /* RUMP_KERNEL_IS_LIBC */
2848 
2849 int rump___sysimpl__ksem_post(intptr_t);
2850 int
2851 rump___sysimpl__ksem_post(intptr_t id)
2852 {
2853 	register_t retval[2];
2854 	int error = 0;
2855 	int rv = -1;
2856 	struct sys__ksem_post_args callarg;
2857 
2858 	memset(&callarg, 0, sizeof(callarg));
2859 	SPARG(&callarg, id) = id;
2860 
2861 	error = rsys_syscall(SYS__ksem_post, &callarg, sizeof(callarg), retval);
2862 	rsys_seterrno(error);
2863 	if (error == 0) {
2864 		if (sizeof(int) > sizeof(register_t))
2865 			rv = *(int *)retval;
2866 		else
2867 			rv = *retval;
2868 	}
2869 	return rv;
2870 }
2871 #ifdef RUMP_KERNEL_IS_LIBC
2872 __weak_alias(_ksem_post,rump___sysimpl__ksem_post);
2873 __weak_alias(__ksem_post,rump___sysimpl__ksem_post);
2874 __strong_alias(_sys__ksem_post,rump___sysimpl__ksem_post);
2875 #endif /* RUMP_KERNEL_IS_LIBC */
2876 
2877 int rump___sysimpl__ksem_wait(intptr_t);
2878 int
2879 rump___sysimpl__ksem_wait(intptr_t id)
2880 {
2881 	register_t retval[2];
2882 	int error = 0;
2883 	int rv = -1;
2884 	struct sys__ksem_wait_args callarg;
2885 
2886 	memset(&callarg, 0, sizeof(callarg));
2887 	SPARG(&callarg, id) = id;
2888 
2889 	error = rsys_syscall(SYS__ksem_wait, &callarg, sizeof(callarg), retval);
2890 	rsys_seterrno(error);
2891 	if (error == 0) {
2892 		if (sizeof(int) > sizeof(register_t))
2893 			rv = *(int *)retval;
2894 		else
2895 			rv = *retval;
2896 	}
2897 	return rv;
2898 }
2899 #ifdef RUMP_KERNEL_IS_LIBC
2900 __weak_alias(_ksem_wait,rump___sysimpl__ksem_wait);
2901 __weak_alias(__ksem_wait,rump___sysimpl__ksem_wait);
2902 __strong_alias(_sys__ksem_wait,rump___sysimpl__ksem_wait);
2903 #endif /* RUMP_KERNEL_IS_LIBC */
2904 
2905 int rump___sysimpl__ksem_trywait(intptr_t);
2906 int
2907 rump___sysimpl__ksem_trywait(intptr_t id)
2908 {
2909 	register_t retval[2];
2910 	int error = 0;
2911 	int rv = -1;
2912 	struct sys__ksem_trywait_args callarg;
2913 
2914 	memset(&callarg, 0, sizeof(callarg));
2915 	SPARG(&callarg, id) = id;
2916 
2917 	error = rsys_syscall(SYS__ksem_trywait, &callarg, sizeof(callarg), retval);
2918 	rsys_seterrno(error);
2919 	if (error == 0) {
2920 		if (sizeof(int) > sizeof(register_t))
2921 			rv = *(int *)retval;
2922 		else
2923 			rv = *retval;
2924 	}
2925 	return rv;
2926 }
2927 #ifdef RUMP_KERNEL_IS_LIBC
2928 __weak_alias(_ksem_trywait,rump___sysimpl__ksem_trywait);
2929 __weak_alias(__ksem_trywait,rump___sysimpl__ksem_trywait);
2930 __strong_alias(_sys__ksem_trywait,rump___sysimpl__ksem_trywait);
2931 #endif /* RUMP_KERNEL_IS_LIBC */
2932 
2933 int rump___sysimpl__ksem_getvalue(intptr_t, unsigned int *);
2934 int
2935 rump___sysimpl__ksem_getvalue(intptr_t id, unsigned int * value)
2936 {
2937 	register_t retval[2];
2938 	int error = 0;
2939 	int rv = -1;
2940 	struct sys__ksem_getvalue_args callarg;
2941 
2942 	memset(&callarg, 0, sizeof(callarg));
2943 	SPARG(&callarg, id) = id;
2944 	SPARG(&callarg, value) = value;
2945 
2946 	error = rsys_syscall(SYS__ksem_getvalue, &callarg, sizeof(callarg), retval);
2947 	rsys_seterrno(error);
2948 	if (error == 0) {
2949 		if (sizeof(int) > sizeof(register_t))
2950 			rv = *(int *)retval;
2951 		else
2952 			rv = *retval;
2953 	}
2954 	return rv;
2955 }
2956 #ifdef RUMP_KERNEL_IS_LIBC
2957 __weak_alias(_ksem_getvalue,rump___sysimpl__ksem_getvalue);
2958 __weak_alias(__ksem_getvalue,rump___sysimpl__ksem_getvalue);
2959 __strong_alias(_sys__ksem_getvalue,rump___sysimpl__ksem_getvalue);
2960 #endif /* RUMP_KERNEL_IS_LIBC */
2961 
2962 int rump___sysimpl__ksem_destroy(intptr_t);
2963 int
2964 rump___sysimpl__ksem_destroy(intptr_t id)
2965 {
2966 	register_t retval[2];
2967 	int error = 0;
2968 	int rv = -1;
2969 	struct sys__ksem_destroy_args callarg;
2970 
2971 	memset(&callarg, 0, sizeof(callarg));
2972 	SPARG(&callarg, id) = id;
2973 
2974 	error = rsys_syscall(SYS__ksem_destroy, &callarg, sizeof(callarg), retval);
2975 	rsys_seterrno(error);
2976 	if (error == 0) {
2977 		if (sizeof(int) > sizeof(register_t))
2978 			rv = *(int *)retval;
2979 		else
2980 			rv = *retval;
2981 	}
2982 	return rv;
2983 }
2984 #ifdef RUMP_KERNEL_IS_LIBC
2985 __weak_alias(_ksem_destroy,rump___sysimpl__ksem_destroy);
2986 __weak_alias(__ksem_destroy,rump___sysimpl__ksem_destroy);
2987 __strong_alias(_sys__ksem_destroy,rump___sysimpl__ksem_destroy);
2988 #endif /* RUMP_KERNEL_IS_LIBC */
2989 
2990 int rump___sysimpl__ksem_timedwait(intptr_t, const struct timespec *);
2991 int
2992 rump___sysimpl__ksem_timedwait(intptr_t id, const struct timespec * abstime)
2993 {
2994 	register_t retval[2];
2995 	int error = 0;
2996 	int rv = -1;
2997 	struct sys__ksem_timedwait_args callarg;
2998 
2999 	memset(&callarg, 0, sizeof(callarg));
3000 	SPARG(&callarg, id) = id;
3001 	SPARG(&callarg, abstime) = abstime;
3002 
3003 	error = rsys_syscall(SYS__ksem_timedwait, &callarg, sizeof(callarg), retval);
3004 	rsys_seterrno(error);
3005 	if (error == 0) {
3006 		if (sizeof(int) > sizeof(register_t))
3007 			rv = *(int *)retval;
3008 		else
3009 			rv = *retval;
3010 	}
3011 	return rv;
3012 }
3013 #ifdef RUMP_KERNEL_IS_LIBC
3014 __weak_alias(_ksem_timedwait,rump___sysimpl__ksem_timedwait);
3015 __weak_alias(__ksem_timedwait,rump___sysimpl__ksem_timedwait);
3016 __strong_alias(_sys__ksem_timedwait,rump___sysimpl__ksem_timedwait);
3017 #endif /* RUMP_KERNEL_IS_LIBC */
3018 
3019 int rump___sysimpl___posix_rename(const char *, const char *);
3020 int
3021 rump___sysimpl___posix_rename(const char * from, const char * to)
3022 {
3023 	register_t retval[2];
3024 	int error = 0;
3025 	int rv = -1;
3026 	struct sys___posix_rename_args callarg;
3027 
3028 	memset(&callarg, 0, sizeof(callarg));
3029 	SPARG(&callarg, from) = from;
3030 	SPARG(&callarg, to) = to;
3031 
3032 	error = rsys_syscall(SYS___posix_rename, &callarg, sizeof(callarg), retval);
3033 	rsys_seterrno(error);
3034 	if (error == 0) {
3035 		if (sizeof(int) > sizeof(register_t))
3036 			rv = *(int *)retval;
3037 		else
3038 			rv = *retval;
3039 	}
3040 	return rv;
3041 }
3042 #ifdef RUMP_KERNEL_IS_LIBC
3043 __weak_alias(__posix_rename,rump___sysimpl___posix_rename);
3044 __weak_alias(___posix_rename,rump___sysimpl___posix_rename);
3045 __strong_alias(_sys___posix_rename,rump___sysimpl___posix_rename);
3046 #endif /* RUMP_KERNEL_IS_LIBC */
3047 
3048 int rump___sysimpl_lchmod(const char *, mode_t);
3049 int
3050 rump___sysimpl_lchmod(const char * path, mode_t mode)
3051 {
3052 	register_t retval[2];
3053 	int error = 0;
3054 	int rv = -1;
3055 	struct sys_lchmod_args callarg;
3056 
3057 	memset(&callarg, 0, sizeof(callarg));
3058 	SPARG(&callarg, path) = path;
3059 	SPARG(&callarg, mode) = mode;
3060 
3061 	error = rsys_syscall(SYS_lchmod, &callarg, sizeof(callarg), retval);
3062 	rsys_seterrno(error);
3063 	if (error == 0) {
3064 		if (sizeof(int) > sizeof(register_t))
3065 			rv = *(int *)retval;
3066 		else
3067 			rv = *retval;
3068 	}
3069 	return rv;
3070 }
3071 #ifdef RUMP_KERNEL_IS_LIBC
3072 __weak_alias(lchmod,rump___sysimpl_lchmod);
3073 __weak_alias(_lchmod,rump___sysimpl_lchmod);
3074 __strong_alias(_sys_lchmod,rump___sysimpl_lchmod);
3075 #endif /* RUMP_KERNEL_IS_LIBC */
3076 
3077 int rump___sysimpl_lchown(const char *, uid_t, gid_t);
3078 int
3079 rump___sysimpl_lchown(const char * path, uid_t uid, gid_t gid)
3080 {
3081 	register_t retval[2];
3082 	int error = 0;
3083 	int rv = -1;
3084 	struct sys_lchown_args callarg;
3085 
3086 	memset(&callarg, 0, sizeof(callarg));
3087 	SPARG(&callarg, path) = path;
3088 	SPARG(&callarg, uid) = uid;
3089 	SPARG(&callarg, gid) = gid;
3090 
3091 	error = rsys_syscall(SYS_lchown, &callarg, sizeof(callarg), retval);
3092 	rsys_seterrno(error);
3093 	if (error == 0) {
3094 		if (sizeof(int) > sizeof(register_t))
3095 			rv = *(int *)retval;
3096 		else
3097 			rv = *retval;
3098 	}
3099 	return rv;
3100 }
3101 #ifdef RUMP_KERNEL_IS_LIBC
3102 __weak_alias(lchown,rump___sysimpl_lchown);
3103 __weak_alias(_lchown,rump___sysimpl_lchown);
3104 __strong_alias(_sys_lchown,rump___sysimpl_lchown);
3105 #endif /* RUMP_KERNEL_IS_LIBC */
3106 
3107 #ifdef RUMP_SYS_COMPAT
3108 int rump___sysimpl_lutimes(const char *, const struct timeval *);
3109 int
3110 rump___sysimpl_lutimes(const char * path, const struct timeval * tptr)
3111 {
3112 	register_t retval[2];
3113 	int error = 0;
3114 	int rv = -1;
3115 	struct compat_50_sys_lutimes_args callarg;
3116 
3117 	memset(&callarg, 0, sizeof(callarg));
3118 	SPARG(&callarg, path) = path;
3119 	SPARG(&callarg, tptr) = (const struct timeval50 *)tptr;
3120 
3121 	error = rsys_syscall(SYS_compat_50_lutimes, &callarg, sizeof(callarg), retval);
3122 	rsys_seterrno(error);
3123 	if (error == 0) {
3124 		if (sizeof(int) > sizeof(register_t))
3125 			rv = *(int *)retval;
3126 		else
3127 			rv = *retval;
3128 	}
3129 	return rv;
3130 }
3131 #ifdef RUMP_KERNEL_IS_LIBC
3132 __weak_alias(lutimes,rump___sysimpl_lutimes);
3133 __weak_alias(_lutimes,rump___sysimpl_lutimes);
3134 __strong_alias(_sys_lutimes,rump___sysimpl_lutimes);
3135 #endif /* RUMP_KERNEL_IS_LIBC */
3136 #endif /* RUMP_SYS_COMPAT */
3137 
3138 int rump___sysimpl___posix_chown(const char *, uid_t, gid_t);
3139 int
3140 rump___sysimpl___posix_chown(const char * path, uid_t uid, gid_t gid)
3141 {
3142 	register_t retval[2];
3143 	int error = 0;
3144 	int rv = -1;
3145 	struct sys___posix_chown_args callarg;
3146 
3147 	memset(&callarg, 0, sizeof(callarg));
3148 	SPARG(&callarg, path) = path;
3149 	SPARG(&callarg, uid) = uid;
3150 	SPARG(&callarg, gid) = gid;
3151 
3152 	error = rsys_syscall(SYS___posix_chown, &callarg, sizeof(callarg), retval);
3153 	rsys_seterrno(error);
3154 	if (error == 0) {
3155 		if (sizeof(int) > sizeof(register_t))
3156 			rv = *(int *)retval;
3157 		else
3158 			rv = *retval;
3159 	}
3160 	return rv;
3161 }
3162 #ifdef RUMP_KERNEL_IS_LIBC
3163 __weak_alias(__posix_chown,rump___sysimpl___posix_chown);
3164 __weak_alias(___posix_chown,rump___sysimpl___posix_chown);
3165 __strong_alias(_sys___posix_chown,rump___sysimpl___posix_chown);
3166 #endif /* RUMP_KERNEL_IS_LIBC */
3167 
3168 int rump___sysimpl___posix_fchown(int, uid_t, gid_t);
3169 int
3170 rump___sysimpl___posix_fchown(int fd, uid_t uid, gid_t gid)
3171 {
3172 	register_t retval[2];
3173 	int error = 0;
3174 	int rv = -1;
3175 	struct sys___posix_fchown_args callarg;
3176 
3177 	memset(&callarg, 0, sizeof(callarg));
3178 	SPARG(&callarg, fd) = fd;
3179 	SPARG(&callarg, uid) = uid;
3180 	SPARG(&callarg, gid) = gid;
3181 
3182 	error = rsys_syscall(SYS___posix_fchown, &callarg, sizeof(callarg), retval);
3183 	rsys_seterrno(error);
3184 	if (error == 0) {
3185 		if (sizeof(int) > sizeof(register_t))
3186 			rv = *(int *)retval;
3187 		else
3188 			rv = *retval;
3189 	}
3190 	return rv;
3191 }
3192 #ifdef RUMP_KERNEL_IS_LIBC
3193 __weak_alias(__posix_fchown,rump___sysimpl___posix_fchown);
3194 __weak_alias(___posix_fchown,rump___sysimpl___posix_fchown);
3195 __strong_alias(_sys___posix_fchown,rump___sysimpl___posix_fchown);
3196 #endif /* RUMP_KERNEL_IS_LIBC */
3197 
3198 int rump___sysimpl___posix_lchown(const char *, uid_t, gid_t);
3199 int
3200 rump___sysimpl___posix_lchown(const char * path, uid_t uid, gid_t gid)
3201 {
3202 	register_t retval[2];
3203 	int error = 0;
3204 	int rv = -1;
3205 	struct sys___posix_lchown_args callarg;
3206 
3207 	memset(&callarg, 0, sizeof(callarg));
3208 	SPARG(&callarg, path) = path;
3209 	SPARG(&callarg, uid) = uid;
3210 	SPARG(&callarg, gid) = gid;
3211 
3212 	error = rsys_syscall(SYS___posix_lchown, &callarg, sizeof(callarg), retval);
3213 	rsys_seterrno(error);
3214 	if (error == 0) {
3215 		if (sizeof(int) > sizeof(register_t))
3216 			rv = *(int *)retval;
3217 		else
3218 			rv = *retval;
3219 	}
3220 	return rv;
3221 }
3222 #ifdef RUMP_KERNEL_IS_LIBC
3223 __weak_alias(__posix_lchown,rump___sysimpl___posix_lchown);
3224 __weak_alias(___posix_lchown,rump___sysimpl___posix_lchown);
3225 __strong_alias(_sys___posix_lchown,rump___sysimpl___posix_lchown);
3226 #endif /* RUMP_KERNEL_IS_LIBC */
3227 
3228 pid_t rump___sysimpl_getsid(pid_t);
3229 pid_t
3230 rump___sysimpl_getsid(pid_t pid)
3231 {
3232 	register_t retval[2];
3233 	int error = 0;
3234 	pid_t rv = -1;
3235 	struct sys_getsid_args callarg;
3236 
3237 	memset(&callarg, 0, sizeof(callarg));
3238 	SPARG(&callarg, pid) = pid;
3239 
3240 	error = rsys_syscall(SYS_getsid, &callarg, sizeof(callarg), retval);
3241 	rsys_seterrno(error);
3242 	if (error == 0) {
3243 		if (sizeof(pid_t) > sizeof(register_t))
3244 			rv = *(pid_t *)retval;
3245 		else
3246 			rv = *retval;
3247 	}
3248 	return rv;
3249 }
3250 #ifdef RUMP_KERNEL_IS_LIBC
3251 __weak_alias(getsid,rump___sysimpl_getsid);
3252 __weak_alias(_getsid,rump___sysimpl_getsid);
3253 __strong_alias(_sys_getsid,rump___sysimpl_getsid);
3254 #endif /* RUMP_KERNEL_IS_LIBC */
3255 
3256 int rump___sysimpl_fktrace(int, int, int, pid_t);
3257 int
3258 rump___sysimpl_fktrace(int fd, int ops, int facs, pid_t pid)
3259 {
3260 	register_t retval[2];
3261 	int error = 0;
3262 	int rv = -1;
3263 	struct sys_fktrace_args callarg;
3264 
3265 	memset(&callarg, 0, sizeof(callarg));
3266 	SPARG(&callarg, fd) = fd;
3267 	SPARG(&callarg, ops) = ops;
3268 	SPARG(&callarg, facs) = facs;
3269 	SPARG(&callarg, pid) = pid;
3270 
3271 	error = rsys_syscall(SYS_fktrace, &callarg, sizeof(callarg), retval);
3272 	rsys_seterrno(error);
3273 	if (error == 0) {
3274 		if (sizeof(int) > sizeof(register_t))
3275 			rv = *(int *)retval;
3276 		else
3277 			rv = *retval;
3278 	}
3279 	return rv;
3280 }
3281 #ifdef RUMP_KERNEL_IS_LIBC
3282 __weak_alias(fktrace,rump___sysimpl_fktrace);
3283 __weak_alias(_fktrace,rump___sysimpl_fktrace);
3284 __strong_alias(_sys_fktrace,rump___sysimpl_fktrace);
3285 #endif /* RUMP_KERNEL_IS_LIBC */
3286 
3287 ssize_t rump___sysimpl_preadv(int, const struct iovec *, int, off_t);
3288 ssize_t
3289 rump___sysimpl_preadv(int fd, const struct iovec * iovp, int iovcnt, off_t offset)
3290 {
3291 	register_t retval[2];
3292 	int error = 0;
3293 	ssize_t rv = -1;
3294 	struct sys_preadv_args callarg;
3295 
3296 	memset(&callarg, 0, sizeof(callarg));
3297 	SPARG(&callarg, fd) = fd;
3298 	SPARG(&callarg, iovp) = iovp;
3299 	SPARG(&callarg, iovcnt) = iovcnt;
3300 	SPARG(&callarg, PAD) = 0;
3301 	SPARG(&callarg, offset) = offset;
3302 
3303 	error = rsys_syscall(SYS_preadv, &callarg, sizeof(callarg), retval);
3304 	rsys_seterrno(error);
3305 	if (error == 0) {
3306 		if (sizeof(ssize_t) > sizeof(register_t))
3307 			rv = *(ssize_t *)retval;
3308 		else
3309 			rv = *retval;
3310 	}
3311 	return rv;
3312 }
3313 #ifdef RUMP_KERNEL_IS_LIBC
3314 __weak_alias(preadv,rump___sysimpl_preadv);
3315 __weak_alias(_preadv,rump___sysimpl_preadv);
3316 __strong_alias(_sys_preadv,rump___sysimpl_preadv);
3317 #endif /* RUMP_KERNEL_IS_LIBC */
3318 
3319 ssize_t rump___sysimpl_pwritev(int, const struct iovec *, int, off_t);
3320 ssize_t
3321 rump___sysimpl_pwritev(int fd, const struct iovec * iovp, int iovcnt, off_t offset)
3322 {
3323 	register_t retval[2];
3324 	int error = 0;
3325 	ssize_t rv = -1;
3326 	struct sys_pwritev_args callarg;
3327 
3328 	memset(&callarg, 0, sizeof(callarg));
3329 	SPARG(&callarg, fd) = fd;
3330 	SPARG(&callarg, iovp) = iovp;
3331 	SPARG(&callarg, iovcnt) = iovcnt;
3332 	SPARG(&callarg, PAD) = 0;
3333 	SPARG(&callarg, offset) = offset;
3334 
3335 	error = rsys_syscall(SYS_pwritev, &callarg, sizeof(callarg), retval);
3336 	rsys_seterrno(error);
3337 	if (error == 0) {
3338 		if (sizeof(ssize_t) > sizeof(register_t))
3339 			rv = *(ssize_t *)retval;
3340 		else
3341 			rv = *retval;
3342 	}
3343 	return rv;
3344 }
3345 #ifdef RUMP_KERNEL_IS_LIBC
3346 __weak_alias(pwritev,rump___sysimpl_pwritev);
3347 __weak_alias(_pwritev,rump___sysimpl_pwritev);
3348 __strong_alias(_sys_pwritev,rump___sysimpl_pwritev);
3349 #endif /* RUMP_KERNEL_IS_LIBC */
3350 
3351 int rump___sysimpl___getcwd(char *, size_t);
3352 int
3353 rump___sysimpl___getcwd(char * bufp, size_t length)
3354 {
3355 	register_t retval[2];
3356 	int error = 0;
3357 	int rv = -1;
3358 	struct sys___getcwd_args callarg;
3359 
3360 	memset(&callarg, 0, sizeof(callarg));
3361 	SPARG(&callarg, bufp) = bufp;
3362 	SPARG(&callarg, length) = length;
3363 
3364 	error = rsys_syscall(SYS___getcwd, &callarg, sizeof(callarg), retval);
3365 	rsys_seterrno(error);
3366 	if (error == 0) {
3367 		if (sizeof(int) > sizeof(register_t))
3368 			rv = *(int *)retval;
3369 		else
3370 			rv = *retval;
3371 	}
3372 	return rv;
3373 }
3374 #ifdef RUMP_KERNEL_IS_LIBC
3375 __weak_alias(__getcwd,rump___sysimpl___getcwd);
3376 __weak_alias(___getcwd,rump___sysimpl___getcwd);
3377 __strong_alias(_sys___getcwd,rump___sysimpl___getcwd);
3378 #endif /* RUMP_KERNEL_IS_LIBC */
3379 
3380 int rump___sysimpl_fchroot(int);
3381 int
3382 rump___sysimpl_fchroot(int fd)
3383 {
3384 	register_t retval[2];
3385 	int error = 0;
3386 	int rv = -1;
3387 	struct sys_fchroot_args callarg;
3388 
3389 	memset(&callarg, 0, sizeof(callarg));
3390 	SPARG(&callarg, fd) = fd;
3391 
3392 	error = rsys_syscall(SYS_fchroot, &callarg, sizeof(callarg), retval);
3393 	rsys_seterrno(error);
3394 	if (error == 0) {
3395 		if (sizeof(int) > sizeof(register_t))
3396 			rv = *(int *)retval;
3397 		else
3398 			rv = *retval;
3399 	}
3400 	return rv;
3401 }
3402 #ifdef RUMP_KERNEL_IS_LIBC
3403 __weak_alias(fchroot,rump___sysimpl_fchroot);
3404 __weak_alias(_fchroot,rump___sysimpl_fchroot);
3405 __strong_alias(_sys_fchroot,rump___sysimpl_fchroot);
3406 #endif /* RUMP_KERNEL_IS_LIBC */
3407 
3408 int rump___sysimpl_lchflags(const char *, u_long);
3409 int
3410 rump___sysimpl_lchflags(const char * path, u_long flags)
3411 {
3412 	register_t retval[2];
3413 	int error = 0;
3414 	int rv = -1;
3415 	struct sys_lchflags_args callarg;
3416 
3417 	memset(&callarg, 0, sizeof(callarg));
3418 	SPARG(&callarg, path) = path;
3419 	SPARG(&callarg, flags) = flags;
3420 
3421 	error = rsys_syscall(SYS_lchflags, &callarg, sizeof(callarg), retval);
3422 	rsys_seterrno(error);
3423 	if (error == 0) {
3424 		if (sizeof(int) > sizeof(register_t))
3425 			rv = *(int *)retval;
3426 		else
3427 			rv = *retval;
3428 	}
3429 	return rv;
3430 }
3431 #ifdef RUMP_KERNEL_IS_LIBC
3432 __weak_alias(lchflags,rump___sysimpl_lchflags);
3433 __weak_alias(_lchflags,rump___sysimpl_lchflags);
3434 __strong_alias(_sys_lchflags,rump___sysimpl_lchflags);
3435 #endif /* RUMP_KERNEL_IS_LIBC */
3436 
3437 int rump___sysimpl_issetugid(void);
3438 int
3439 rump___sysimpl_issetugid(void )
3440 {
3441 	register_t retval[2];
3442 	int rv = -1;
3443 
3444 	(void)rsys_syscall(SYS_issetugid, NULL, 0, retval);
3445 	if (sizeof(int) > sizeof(register_t))
3446 		rv = *(int *)retval;
3447 	else
3448 		rv = *retval;
3449 	return rv;
3450 }
3451 #ifdef RUMP_KERNEL_IS_LIBC
3452 __weak_alias(issetugid,rump___sysimpl_issetugid);
3453 __weak_alias(_issetugid,rump___sysimpl_issetugid);
3454 __strong_alias(_sys_issetugid,rump___sysimpl_issetugid);
3455 #endif /* RUMP_KERNEL_IS_LIBC */
3456 
3457 int rump___sysimpl_utrace(const char *, void *, size_t);
3458 int
3459 rump___sysimpl_utrace(const char * label, void * addr, size_t len)
3460 {
3461 	register_t retval[2];
3462 	int error = 0;
3463 	int rv = -1;
3464 	struct sys_utrace_args callarg;
3465 
3466 	memset(&callarg, 0, sizeof(callarg));
3467 	SPARG(&callarg, label) = label;
3468 	SPARG(&callarg, addr) = addr;
3469 	SPARG(&callarg, len) = len;
3470 
3471 	error = rsys_syscall(SYS_utrace, &callarg, sizeof(callarg), retval);
3472 	rsys_seterrno(error);
3473 	if (error == 0) {
3474 		if (sizeof(int) > sizeof(register_t))
3475 			rv = *(int *)retval;
3476 		else
3477 			rv = *retval;
3478 	}
3479 	return rv;
3480 }
3481 #ifdef RUMP_KERNEL_IS_LIBC
3482 __weak_alias(utrace,rump___sysimpl_utrace);
3483 __weak_alias(_utrace,rump___sysimpl_utrace);
3484 __strong_alias(_sys_utrace,rump___sysimpl_utrace);
3485 #endif /* RUMP_KERNEL_IS_LIBC */
3486 
3487 int rump___sysimpl_kqueue(void);
3488 int
3489 rump___sysimpl_kqueue(void )
3490 {
3491 	register_t retval[2];
3492 	int error = 0;
3493 	int rv = -1;
3494 
3495 	error = rsys_syscall(SYS_kqueue, NULL, 0, retval);
3496 	rsys_seterrno(error);
3497 	if (error == 0) {
3498 		if (sizeof(int) > sizeof(register_t))
3499 			rv = *(int *)retval;
3500 		else
3501 			rv = *retval;
3502 	}
3503 	return rv;
3504 }
3505 #ifdef RUMP_KERNEL_IS_LIBC
3506 __weak_alias(kqueue,rump___sysimpl_kqueue);
3507 __weak_alias(_kqueue,rump___sysimpl_kqueue);
3508 __strong_alias(_sys_kqueue,rump___sysimpl_kqueue);
3509 #endif /* RUMP_KERNEL_IS_LIBC */
3510 
3511 #ifdef RUMP_SYS_COMPAT
3512 int rump___sysimpl_kevent(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *);
3513 int
3514 rump___sysimpl_kevent(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout)
3515 {
3516 	register_t retval[2];
3517 	int error = 0;
3518 	int rv = -1;
3519 	struct compat_50_sys_kevent_args callarg;
3520 
3521 	memset(&callarg, 0, sizeof(callarg));
3522 	SPARG(&callarg, fd) = fd;
3523 	SPARG(&callarg, changelist) = (const struct kevent100 *)changelist;
3524 	SPARG(&callarg, nchanges) = nchanges;
3525 	SPARG(&callarg, eventlist) = (struct kevent100 *)eventlist;
3526 	SPARG(&callarg, nevents) = nevents;
3527 	SPARG(&callarg, timeout) = (const struct timespec50 *)timeout;
3528 
3529 	error = rsys_syscall(SYS_compat_50_kevent, &callarg, sizeof(callarg), retval);
3530 	rsys_seterrno(error);
3531 	if (error == 0) {
3532 		if (sizeof(int) > sizeof(register_t))
3533 			rv = *(int *)retval;
3534 		else
3535 			rv = *retval;
3536 	}
3537 	return rv;
3538 }
3539 #ifdef RUMP_KERNEL_IS_LIBC
3540 __weak_alias(kevent,rump___sysimpl_kevent);
3541 __weak_alias(_kevent,rump___sysimpl_kevent);
3542 __strong_alias(_sys_kevent,rump___sysimpl_kevent);
3543 #endif /* RUMP_KERNEL_IS_LIBC */
3544 #endif /* RUMP_SYS_COMPAT */
3545 
3546 int rump___sysimpl_fsync_range(int, int, off_t, off_t);
3547 int
3548 rump___sysimpl_fsync_range(int fd, int flags, off_t start, off_t length)
3549 {
3550 	register_t retval[2];
3551 	int error = 0;
3552 	int rv = -1;
3553 	struct sys_fsync_range_args callarg;
3554 
3555 	memset(&callarg, 0, sizeof(callarg));
3556 	SPARG(&callarg, fd) = fd;
3557 	SPARG(&callarg, flags) = flags;
3558 	SPARG(&callarg, start) = start;
3559 	SPARG(&callarg, length) = length;
3560 
3561 	error = rsys_syscall(SYS_fsync_range, &callarg, sizeof(callarg), retval);
3562 	rsys_seterrno(error);
3563 	if (error == 0) {
3564 		if (sizeof(int) > sizeof(register_t))
3565 			rv = *(int *)retval;
3566 		else
3567 			rv = *retval;
3568 	}
3569 	return rv;
3570 }
3571 #ifdef RUMP_KERNEL_IS_LIBC
3572 __weak_alias(fsync_range,rump___sysimpl_fsync_range);
3573 __weak_alias(_fsync_range,rump___sysimpl_fsync_range);
3574 __strong_alias(_sys_fsync_range,rump___sysimpl_fsync_range);
3575 #endif /* RUMP_KERNEL_IS_LIBC */
3576 
3577 int rump___sysimpl_extattrctl(const char *, int, const char *, int, const char *);
3578 int
3579 rump___sysimpl_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname)
3580 {
3581 	register_t retval[2];
3582 	int error = 0;
3583 	int rv = -1;
3584 	struct sys_extattrctl_args callarg;
3585 
3586 	memset(&callarg, 0, sizeof(callarg));
3587 	SPARG(&callarg, path) = path;
3588 	SPARG(&callarg, cmd) = cmd;
3589 	SPARG(&callarg, filename) = filename;
3590 	SPARG(&callarg, attrnamespace) = attrnamespace;
3591 	SPARG(&callarg, attrname) = attrname;
3592 
3593 	error = rsys_syscall(SYS_extattrctl, &callarg, sizeof(callarg), retval);
3594 	rsys_seterrno(error);
3595 	if (error == 0) {
3596 		if (sizeof(int) > sizeof(register_t))
3597 			rv = *(int *)retval;
3598 		else
3599 			rv = *retval;
3600 	}
3601 	return rv;
3602 }
3603 #ifdef RUMP_KERNEL_IS_LIBC
3604 __weak_alias(extattrctl,rump___sysimpl_extattrctl);
3605 __weak_alias(_extattrctl,rump___sysimpl_extattrctl);
3606 __strong_alias(_sys_extattrctl,rump___sysimpl_extattrctl);
3607 #endif /* RUMP_KERNEL_IS_LIBC */
3608 
3609 int rump___sysimpl_extattr_set_file(const char *, int, const char *, const void *, size_t);
3610 int
3611 rump___sysimpl_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
3612 {
3613 	register_t retval[2];
3614 	int error = 0;
3615 	int rv = -1;
3616 	struct sys_extattr_set_file_args callarg;
3617 
3618 	memset(&callarg, 0, sizeof(callarg));
3619 	SPARG(&callarg, path) = path;
3620 	SPARG(&callarg, attrnamespace) = attrnamespace;
3621 	SPARG(&callarg, attrname) = attrname;
3622 	SPARG(&callarg, data) = data;
3623 	SPARG(&callarg, nbytes) = nbytes;
3624 
3625 	error = rsys_syscall(SYS_extattr_set_file, &callarg, sizeof(callarg), retval);
3626 	rsys_seterrno(error);
3627 	if (error == 0) {
3628 		if (sizeof(int) > sizeof(register_t))
3629 			rv = *(int *)retval;
3630 		else
3631 			rv = *retval;
3632 	}
3633 	return rv;
3634 }
3635 #ifdef RUMP_KERNEL_IS_LIBC
3636 __weak_alias(extattr_set_file,rump___sysimpl_extattr_set_file);
3637 __weak_alias(_extattr_set_file,rump___sysimpl_extattr_set_file);
3638 __strong_alias(_sys_extattr_set_file,rump___sysimpl_extattr_set_file);
3639 #endif /* RUMP_KERNEL_IS_LIBC */
3640 
3641 ssize_t rump___sysimpl_extattr_get_file(const char *, int, const char *, void *, size_t);
3642 ssize_t
3643 rump___sysimpl_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes)
3644 {
3645 	register_t retval[2];
3646 	int error = 0;
3647 	ssize_t rv = -1;
3648 	struct sys_extattr_get_file_args callarg;
3649 
3650 	memset(&callarg, 0, sizeof(callarg));
3651 	SPARG(&callarg, path) = path;
3652 	SPARG(&callarg, attrnamespace) = attrnamespace;
3653 	SPARG(&callarg, attrname) = attrname;
3654 	SPARG(&callarg, data) = data;
3655 	SPARG(&callarg, nbytes) = nbytes;
3656 
3657 	error = rsys_syscall(SYS_extattr_get_file, &callarg, sizeof(callarg), retval);
3658 	rsys_seterrno(error);
3659 	if (error == 0) {
3660 		if (sizeof(ssize_t) > sizeof(register_t))
3661 			rv = *(ssize_t *)retval;
3662 		else
3663 			rv = *retval;
3664 	}
3665 	return rv;
3666 }
3667 #ifdef RUMP_KERNEL_IS_LIBC
3668 __weak_alias(extattr_get_file,rump___sysimpl_extattr_get_file);
3669 __weak_alias(_extattr_get_file,rump___sysimpl_extattr_get_file);
3670 __strong_alias(_sys_extattr_get_file,rump___sysimpl_extattr_get_file);
3671 #endif /* RUMP_KERNEL_IS_LIBC */
3672 
3673 int rump___sysimpl_extattr_delete_file(const char *, int, const char *);
3674 int
3675 rump___sysimpl_extattr_delete_file(const char * path, int attrnamespace, const char * attrname)
3676 {
3677 	register_t retval[2];
3678 	int error = 0;
3679 	int rv = -1;
3680 	struct sys_extattr_delete_file_args callarg;
3681 
3682 	memset(&callarg, 0, sizeof(callarg));
3683 	SPARG(&callarg, path) = path;
3684 	SPARG(&callarg, attrnamespace) = attrnamespace;
3685 	SPARG(&callarg, attrname) = attrname;
3686 
3687 	error = rsys_syscall(SYS_extattr_delete_file, &callarg, sizeof(callarg), retval);
3688 	rsys_seterrno(error);
3689 	if (error == 0) {
3690 		if (sizeof(int) > sizeof(register_t))
3691 			rv = *(int *)retval;
3692 		else
3693 			rv = *retval;
3694 	}
3695 	return rv;
3696 }
3697 #ifdef RUMP_KERNEL_IS_LIBC
3698 __weak_alias(extattr_delete_file,rump___sysimpl_extattr_delete_file);
3699 __weak_alias(_extattr_delete_file,rump___sysimpl_extattr_delete_file);
3700 __strong_alias(_sys_extattr_delete_file,rump___sysimpl_extattr_delete_file);
3701 #endif /* RUMP_KERNEL_IS_LIBC */
3702 
3703 int rump___sysimpl_extattr_set_fd(int, int, const char *, const void *, size_t);
3704 int
3705 rump___sysimpl_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
3706 {
3707 	register_t retval[2];
3708 	int error = 0;
3709 	int rv = -1;
3710 	struct sys_extattr_set_fd_args callarg;
3711 
3712 	memset(&callarg, 0, sizeof(callarg));
3713 	SPARG(&callarg, fd) = fd;
3714 	SPARG(&callarg, attrnamespace) = attrnamespace;
3715 	SPARG(&callarg, attrname) = attrname;
3716 	SPARG(&callarg, data) = data;
3717 	SPARG(&callarg, nbytes) = nbytes;
3718 
3719 	error = rsys_syscall(SYS_extattr_set_fd, &callarg, sizeof(callarg), retval);
3720 	rsys_seterrno(error);
3721 	if (error == 0) {
3722 		if (sizeof(int) > sizeof(register_t))
3723 			rv = *(int *)retval;
3724 		else
3725 			rv = *retval;
3726 	}
3727 	return rv;
3728 }
3729 #ifdef RUMP_KERNEL_IS_LIBC
3730 __weak_alias(extattr_set_fd,rump___sysimpl_extattr_set_fd);
3731 __weak_alias(_extattr_set_fd,rump___sysimpl_extattr_set_fd);
3732 __strong_alias(_sys_extattr_set_fd,rump___sysimpl_extattr_set_fd);
3733 #endif /* RUMP_KERNEL_IS_LIBC */
3734 
3735 ssize_t rump___sysimpl_extattr_get_fd(int, int, const char *, void *, size_t);
3736 ssize_t
3737 rump___sysimpl_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes)
3738 {
3739 	register_t retval[2];
3740 	int error = 0;
3741 	ssize_t rv = -1;
3742 	struct sys_extattr_get_fd_args callarg;
3743 
3744 	memset(&callarg, 0, sizeof(callarg));
3745 	SPARG(&callarg, fd) = fd;
3746 	SPARG(&callarg, attrnamespace) = attrnamespace;
3747 	SPARG(&callarg, attrname) = attrname;
3748 	SPARG(&callarg, data) = data;
3749 	SPARG(&callarg, nbytes) = nbytes;
3750 
3751 	error = rsys_syscall(SYS_extattr_get_fd, &callarg, sizeof(callarg), retval);
3752 	rsys_seterrno(error);
3753 	if (error == 0) {
3754 		if (sizeof(ssize_t) > sizeof(register_t))
3755 			rv = *(ssize_t *)retval;
3756 		else
3757 			rv = *retval;
3758 	}
3759 	return rv;
3760 }
3761 #ifdef RUMP_KERNEL_IS_LIBC
3762 __weak_alias(extattr_get_fd,rump___sysimpl_extattr_get_fd);
3763 __weak_alias(_extattr_get_fd,rump___sysimpl_extattr_get_fd);
3764 __strong_alias(_sys_extattr_get_fd,rump___sysimpl_extattr_get_fd);
3765 #endif /* RUMP_KERNEL_IS_LIBC */
3766 
3767 int rump___sysimpl_extattr_delete_fd(int, int, const char *);
3768 int
3769 rump___sysimpl_extattr_delete_fd(int fd, int attrnamespace, const char * attrname)
3770 {
3771 	register_t retval[2];
3772 	int error = 0;
3773 	int rv = -1;
3774 	struct sys_extattr_delete_fd_args callarg;
3775 
3776 	memset(&callarg, 0, sizeof(callarg));
3777 	SPARG(&callarg, fd) = fd;
3778 	SPARG(&callarg, attrnamespace) = attrnamespace;
3779 	SPARG(&callarg, attrname) = attrname;
3780 
3781 	error = rsys_syscall(SYS_extattr_delete_fd, &callarg, sizeof(callarg), retval);
3782 	rsys_seterrno(error);
3783 	if (error == 0) {
3784 		if (sizeof(int) > sizeof(register_t))
3785 			rv = *(int *)retval;
3786 		else
3787 			rv = *retval;
3788 	}
3789 	return rv;
3790 }
3791 #ifdef RUMP_KERNEL_IS_LIBC
3792 __weak_alias(extattr_delete_fd,rump___sysimpl_extattr_delete_fd);
3793 __weak_alias(_extattr_delete_fd,rump___sysimpl_extattr_delete_fd);
3794 __strong_alias(_sys_extattr_delete_fd,rump___sysimpl_extattr_delete_fd);
3795 #endif /* RUMP_KERNEL_IS_LIBC */
3796 
3797 int rump___sysimpl_extattr_set_link(const char *, int, const char *, const void *, size_t);
3798 int
3799 rump___sysimpl_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
3800 {
3801 	register_t retval[2];
3802 	int error = 0;
3803 	int rv = -1;
3804 	struct sys_extattr_set_link_args callarg;
3805 
3806 	memset(&callarg, 0, sizeof(callarg));
3807 	SPARG(&callarg, path) = path;
3808 	SPARG(&callarg, attrnamespace) = attrnamespace;
3809 	SPARG(&callarg, attrname) = attrname;
3810 	SPARG(&callarg, data) = data;
3811 	SPARG(&callarg, nbytes) = nbytes;
3812 
3813 	error = rsys_syscall(SYS_extattr_set_link, &callarg, sizeof(callarg), retval);
3814 	rsys_seterrno(error);
3815 	if (error == 0) {
3816 		if (sizeof(int) > sizeof(register_t))
3817 			rv = *(int *)retval;
3818 		else
3819 			rv = *retval;
3820 	}
3821 	return rv;
3822 }
3823 #ifdef RUMP_KERNEL_IS_LIBC
3824 __weak_alias(extattr_set_link,rump___sysimpl_extattr_set_link);
3825 __weak_alias(_extattr_set_link,rump___sysimpl_extattr_set_link);
3826 __strong_alias(_sys_extattr_set_link,rump___sysimpl_extattr_set_link);
3827 #endif /* RUMP_KERNEL_IS_LIBC */
3828 
3829 ssize_t rump___sysimpl_extattr_get_link(const char *, int, const char *, void *, size_t);
3830 ssize_t
3831 rump___sysimpl_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes)
3832 {
3833 	register_t retval[2];
3834 	int error = 0;
3835 	ssize_t rv = -1;
3836 	struct sys_extattr_get_link_args callarg;
3837 
3838 	memset(&callarg, 0, sizeof(callarg));
3839 	SPARG(&callarg, path) = path;
3840 	SPARG(&callarg, attrnamespace) = attrnamespace;
3841 	SPARG(&callarg, attrname) = attrname;
3842 	SPARG(&callarg, data) = data;
3843 	SPARG(&callarg, nbytes) = nbytes;
3844 
3845 	error = rsys_syscall(SYS_extattr_get_link, &callarg, sizeof(callarg), retval);
3846 	rsys_seterrno(error);
3847 	if (error == 0) {
3848 		if (sizeof(ssize_t) > sizeof(register_t))
3849 			rv = *(ssize_t *)retval;
3850 		else
3851 			rv = *retval;
3852 	}
3853 	return rv;
3854 }
3855 #ifdef RUMP_KERNEL_IS_LIBC
3856 __weak_alias(extattr_get_link,rump___sysimpl_extattr_get_link);
3857 __weak_alias(_extattr_get_link,rump___sysimpl_extattr_get_link);
3858 __strong_alias(_sys_extattr_get_link,rump___sysimpl_extattr_get_link);
3859 #endif /* RUMP_KERNEL_IS_LIBC */
3860 
3861 int rump___sysimpl_extattr_delete_link(const char *, int, const char *);
3862 int
3863 rump___sysimpl_extattr_delete_link(const char * path, int attrnamespace, const char * attrname)
3864 {
3865 	register_t retval[2];
3866 	int error = 0;
3867 	int rv = -1;
3868 	struct sys_extattr_delete_link_args callarg;
3869 
3870 	memset(&callarg, 0, sizeof(callarg));
3871 	SPARG(&callarg, path) = path;
3872 	SPARG(&callarg, attrnamespace) = attrnamespace;
3873 	SPARG(&callarg, attrname) = attrname;
3874 
3875 	error = rsys_syscall(SYS_extattr_delete_link, &callarg, sizeof(callarg), retval);
3876 	rsys_seterrno(error);
3877 	if (error == 0) {
3878 		if (sizeof(int) > sizeof(register_t))
3879 			rv = *(int *)retval;
3880 		else
3881 			rv = *retval;
3882 	}
3883 	return rv;
3884 }
3885 #ifdef RUMP_KERNEL_IS_LIBC
3886 __weak_alias(extattr_delete_link,rump___sysimpl_extattr_delete_link);
3887 __weak_alias(_extattr_delete_link,rump___sysimpl_extattr_delete_link);
3888 __strong_alias(_sys_extattr_delete_link,rump___sysimpl_extattr_delete_link);
3889 #endif /* RUMP_KERNEL_IS_LIBC */
3890 
3891 ssize_t rump___sysimpl_extattr_list_fd(int, int, void *, size_t);
3892 ssize_t
3893 rump___sysimpl_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes)
3894 {
3895 	register_t retval[2];
3896 	int error = 0;
3897 	ssize_t rv = -1;
3898 	struct sys_extattr_list_fd_args callarg;
3899 
3900 	memset(&callarg, 0, sizeof(callarg));
3901 	SPARG(&callarg, fd) = fd;
3902 	SPARG(&callarg, attrnamespace) = attrnamespace;
3903 	SPARG(&callarg, data) = data;
3904 	SPARG(&callarg, nbytes) = nbytes;
3905 
3906 	error = rsys_syscall(SYS_extattr_list_fd, &callarg, sizeof(callarg), retval);
3907 	rsys_seterrno(error);
3908 	if (error == 0) {
3909 		if (sizeof(ssize_t) > sizeof(register_t))
3910 			rv = *(ssize_t *)retval;
3911 		else
3912 			rv = *retval;
3913 	}
3914 	return rv;
3915 }
3916 #ifdef RUMP_KERNEL_IS_LIBC
3917 __weak_alias(extattr_list_fd,rump___sysimpl_extattr_list_fd);
3918 __weak_alias(_extattr_list_fd,rump___sysimpl_extattr_list_fd);
3919 __strong_alias(_sys_extattr_list_fd,rump___sysimpl_extattr_list_fd);
3920 #endif /* RUMP_KERNEL_IS_LIBC */
3921 
3922 ssize_t rump___sysimpl_extattr_list_file(const char *, int, void *, size_t);
3923 ssize_t
3924 rump___sysimpl_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes)
3925 {
3926 	register_t retval[2];
3927 	int error = 0;
3928 	ssize_t rv = -1;
3929 	struct sys_extattr_list_file_args callarg;
3930 
3931 	memset(&callarg, 0, sizeof(callarg));
3932 	SPARG(&callarg, path) = path;
3933 	SPARG(&callarg, attrnamespace) = attrnamespace;
3934 	SPARG(&callarg, data) = data;
3935 	SPARG(&callarg, nbytes) = nbytes;
3936 
3937 	error = rsys_syscall(SYS_extattr_list_file, &callarg, sizeof(callarg), retval);
3938 	rsys_seterrno(error);
3939 	if (error == 0) {
3940 		if (sizeof(ssize_t) > sizeof(register_t))
3941 			rv = *(ssize_t *)retval;
3942 		else
3943 			rv = *retval;
3944 	}
3945 	return rv;
3946 }
3947 #ifdef RUMP_KERNEL_IS_LIBC
3948 __weak_alias(extattr_list_file,rump___sysimpl_extattr_list_file);
3949 __weak_alias(_extattr_list_file,rump___sysimpl_extattr_list_file);
3950 __strong_alias(_sys_extattr_list_file,rump___sysimpl_extattr_list_file);
3951 #endif /* RUMP_KERNEL_IS_LIBC */
3952 
3953 ssize_t rump___sysimpl_extattr_list_link(const char *, int, void *, size_t);
3954 ssize_t
3955 rump___sysimpl_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes)
3956 {
3957 	register_t retval[2];
3958 	int error = 0;
3959 	ssize_t rv = -1;
3960 	struct sys_extattr_list_link_args callarg;
3961 
3962 	memset(&callarg, 0, sizeof(callarg));
3963 	SPARG(&callarg, path) = path;
3964 	SPARG(&callarg, attrnamespace) = attrnamespace;
3965 	SPARG(&callarg, data) = data;
3966 	SPARG(&callarg, nbytes) = nbytes;
3967 
3968 	error = rsys_syscall(SYS_extattr_list_link, &callarg, sizeof(callarg), retval);
3969 	rsys_seterrno(error);
3970 	if (error == 0) {
3971 		if (sizeof(ssize_t) > sizeof(register_t))
3972 			rv = *(ssize_t *)retval;
3973 		else
3974 			rv = *retval;
3975 	}
3976 	return rv;
3977 }
3978 #ifdef RUMP_KERNEL_IS_LIBC
3979 __weak_alias(extattr_list_link,rump___sysimpl_extattr_list_link);
3980 __weak_alias(_extattr_list_link,rump___sysimpl_extattr_list_link);
3981 __strong_alias(_sys_extattr_list_link,rump___sysimpl_extattr_list_link);
3982 #endif /* RUMP_KERNEL_IS_LIBC */
3983 
3984 #ifdef RUMP_SYS_COMPAT
3985 int rump___sysimpl_pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);
3986 int
3987 rump___sysimpl_pselect(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask)
3988 {
3989 	register_t retval[2];
3990 	int error = 0;
3991 	int rv = -1;
3992 	struct compat_50_sys_pselect_args callarg;
3993 
3994 	memset(&callarg, 0, sizeof(callarg));
3995 	SPARG(&callarg, nd) = nd;
3996 	SPARG(&callarg, in) = in;
3997 	SPARG(&callarg, ou) = ou;
3998 	SPARG(&callarg, ex) = ex;
3999 	SPARG(&callarg, ts) = (const struct timespec50 *)ts;
4000 	SPARG(&callarg, mask) = mask;
4001 
4002 	error = rsys_syscall(SYS_compat_50_pselect, &callarg, sizeof(callarg), retval);
4003 	rsys_seterrno(error);
4004 	if (error == 0) {
4005 		if (sizeof(int) > sizeof(register_t))
4006 			rv = *(int *)retval;
4007 		else
4008 			rv = *retval;
4009 	}
4010 	return rv;
4011 }
4012 #ifdef RUMP_KERNEL_IS_LIBC
4013 __weak_alias(pselect,rump___sysimpl_pselect);
4014 __weak_alias(_pselect,rump___sysimpl_pselect);
4015 __strong_alias(_sys_pselect,rump___sysimpl_pselect);
4016 #endif /* RUMP_KERNEL_IS_LIBC */
4017 #endif /* RUMP_SYS_COMPAT */
4018 
4019 #ifdef RUMP_SYS_COMPAT
4020 int rump___sysimpl_pollts(struct pollfd *, u_int, const struct timespec *, const sigset_t *);
4021 int
4022 rump___sysimpl_pollts(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask)
4023 {
4024 	register_t retval[2];
4025 	int error = 0;
4026 	int rv = -1;
4027 	struct compat_50_sys_pollts_args callarg;
4028 
4029 	memset(&callarg, 0, sizeof(callarg));
4030 	SPARG(&callarg, fds) = fds;
4031 	SPARG(&callarg, nfds) = nfds;
4032 	SPARG(&callarg, ts) = (const struct timespec50 *)ts;
4033 	SPARG(&callarg, mask) = mask;
4034 
4035 	error = rsys_syscall(SYS_compat_50_pollts, &callarg, sizeof(callarg), retval);
4036 	rsys_seterrno(error);
4037 	if (error == 0) {
4038 		if (sizeof(int) > sizeof(register_t))
4039 			rv = *(int *)retval;
4040 		else
4041 			rv = *retval;
4042 	}
4043 	return rv;
4044 }
4045 #ifdef RUMP_KERNEL_IS_LIBC
4046 __weak_alias(pollts,rump___sysimpl_pollts);
4047 __weak_alias(_pollts,rump___sysimpl_pollts);
4048 __strong_alias(_sys_pollts,rump___sysimpl_pollts);
4049 #endif /* RUMP_KERNEL_IS_LIBC */
4050 #endif /* RUMP_SYS_COMPAT */
4051 
4052 int rump___sysimpl_setxattr(const char *, const char *, const void *, size_t, int);
4053 int
4054 rump___sysimpl_setxattr(const char * path, const char * name, const void * value, size_t size, int flags)
4055 {
4056 	register_t retval[2];
4057 	int error = 0;
4058 	int rv = -1;
4059 	struct sys_setxattr_args callarg;
4060 
4061 	memset(&callarg, 0, sizeof(callarg));
4062 	SPARG(&callarg, path) = path;
4063 	SPARG(&callarg, name) = name;
4064 	SPARG(&callarg, value) = value;
4065 	SPARG(&callarg, size) = size;
4066 	SPARG(&callarg, flags) = flags;
4067 
4068 	error = rsys_syscall(SYS_setxattr, &callarg, sizeof(callarg), retval);
4069 	rsys_seterrno(error);
4070 	if (error == 0) {
4071 		if (sizeof(int) > sizeof(register_t))
4072 			rv = *(int *)retval;
4073 		else
4074 			rv = *retval;
4075 	}
4076 	return rv;
4077 }
4078 #ifdef RUMP_KERNEL_IS_LIBC
4079 __weak_alias(setxattr,rump___sysimpl_setxattr);
4080 __weak_alias(_setxattr,rump___sysimpl_setxattr);
4081 __strong_alias(_sys_setxattr,rump___sysimpl_setxattr);
4082 #endif /* RUMP_KERNEL_IS_LIBC */
4083 
4084 int rump___sysimpl_lsetxattr(const char *, const char *, const void *, size_t, int);
4085 int
4086 rump___sysimpl_lsetxattr(const char * path, const char * name, const void * value, size_t size, int flags)
4087 {
4088 	register_t retval[2];
4089 	int error = 0;
4090 	int rv = -1;
4091 	struct sys_lsetxattr_args callarg;
4092 
4093 	memset(&callarg, 0, sizeof(callarg));
4094 	SPARG(&callarg, path) = path;
4095 	SPARG(&callarg, name) = name;
4096 	SPARG(&callarg, value) = value;
4097 	SPARG(&callarg, size) = size;
4098 	SPARG(&callarg, flags) = flags;
4099 
4100 	error = rsys_syscall(SYS_lsetxattr, &callarg, sizeof(callarg), retval);
4101 	rsys_seterrno(error);
4102 	if (error == 0) {
4103 		if (sizeof(int) > sizeof(register_t))
4104 			rv = *(int *)retval;
4105 		else
4106 			rv = *retval;
4107 	}
4108 	return rv;
4109 }
4110 #ifdef RUMP_KERNEL_IS_LIBC
4111 __weak_alias(lsetxattr,rump___sysimpl_lsetxattr);
4112 __weak_alias(_lsetxattr,rump___sysimpl_lsetxattr);
4113 __strong_alias(_sys_lsetxattr,rump___sysimpl_lsetxattr);
4114 #endif /* RUMP_KERNEL_IS_LIBC */
4115 
4116 int rump___sysimpl_fsetxattr(int, const char *, const void *, size_t, int);
4117 int
4118 rump___sysimpl_fsetxattr(int fd, const char * name, const void * value, size_t size, int flags)
4119 {
4120 	register_t retval[2];
4121 	int error = 0;
4122 	int rv = -1;
4123 	struct sys_fsetxattr_args callarg;
4124 
4125 	memset(&callarg, 0, sizeof(callarg));
4126 	SPARG(&callarg, fd) = fd;
4127 	SPARG(&callarg, name) = name;
4128 	SPARG(&callarg, value) = value;
4129 	SPARG(&callarg, size) = size;
4130 	SPARG(&callarg, flags) = flags;
4131 
4132 	error = rsys_syscall(SYS_fsetxattr, &callarg, sizeof(callarg), retval);
4133 	rsys_seterrno(error);
4134 	if (error == 0) {
4135 		if (sizeof(int) > sizeof(register_t))
4136 			rv = *(int *)retval;
4137 		else
4138 			rv = *retval;
4139 	}
4140 	return rv;
4141 }
4142 #ifdef RUMP_KERNEL_IS_LIBC
4143 __weak_alias(fsetxattr,rump___sysimpl_fsetxattr);
4144 __weak_alias(_fsetxattr,rump___sysimpl_fsetxattr);
4145 __strong_alias(_sys_fsetxattr,rump___sysimpl_fsetxattr);
4146 #endif /* RUMP_KERNEL_IS_LIBC */
4147 
4148 int rump___sysimpl_getxattr(const char *, const char *, void *, size_t);
4149 int
4150 rump___sysimpl_getxattr(const char * path, const char * name, void * value, size_t size)
4151 {
4152 	register_t retval[2];
4153 	int error = 0;
4154 	int rv = -1;
4155 	struct sys_getxattr_args callarg;
4156 
4157 	memset(&callarg, 0, sizeof(callarg));
4158 	SPARG(&callarg, path) = path;
4159 	SPARG(&callarg, name) = name;
4160 	SPARG(&callarg, value) = value;
4161 	SPARG(&callarg, size) = size;
4162 
4163 	error = rsys_syscall(SYS_getxattr, &callarg, sizeof(callarg), retval);
4164 	rsys_seterrno(error);
4165 	if (error == 0) {
4166 		if (sizeof(int) > sizeof(register_t))
4167 			rv = *(int *)retval;
4168 		else
4169 			rv = *retval;
4170 	}
4171 	return rv;
4172 }
4173 #ifdef RUMP_KERNEL_IS_LIBC
4174 __weak_alias(getxattr,rump___sysimpl_getxattr);
4175 __weak_alias(_getxattr,rump___sysimpl_getxattr);
4176 __strong_alias(_sys_getxattr,rump___sysimpl_getxattr);
4177 #endif /* RUMP_KERNEL_IS_LIBC */
4178 
4179 int rump___sysimpl_lgetxattr(const char *, const char *, void *, size_t);
4180 int
4181 rump___sysimpl_lgetxattr(const char * path, const char * name, void * value, size_t size)
4182 {
4183 	register_t retval[2];
4184 	int error = 0;
4185 	int rv = -1;
4186 	struct sys_lgetxattr_args callarg;
4187 
4188 	memset(&callarg, 0, sizeof(callarg));
4189 	SPARG(&callarg, path) = path;
4190 	SPARG(&callarg, name) = name;
4191 	SPARG(&callarg, value) = value;
4192 	SPARG(&callarg, size) = size;
4193 
4194 	error = rsys_syscall(SYS_lgetxattr, &callarg, sizeof(callarg), retval);
4195 	rsys_seterrno(error);
4196 	if (error == 0) {
4197 		if (sizeof(int) > sizeof(register_t))
4198 			rv = *(int *)retval;
4199 		else
4200 			rv = *retval;
4201 	}
4202 	return rv;
4203 }
4204 #ifdef RUMP_KERNEL_IS_LIBC
4205 __weak_alias(lgetxattr,rump___sysimpl_lgetxattr);
4206 __weak_alias(_lgetxattr,rump___sysimpl_lgetxattr);
4207 __strong_alias(_sys_lgetxattr,rump___sysimpl_lgetxattr);
4208 #endif /* RUMP_KERNEL_IS_LIBC */
4209 
4210 int rump___sysimpl_fgetxattr(int, const char *, void *, size_t);
4211 int
4212 rump___sysimpl_fgetxattr(int fd, const char * name, void * value, size_t size)
4213 {
4214 	register_t retval[2];
4215 	int error = 0;
4216 	int rv = -1;
4217 	struct sys_fgetxattr_args callarg;
4218 
4219 	memset(&callarg, 0, sizeof(callarg));
4220 	SPARG(&callarg, fd) = fd;
4221 	SPARG(&callarg, name) = name;
4222 	SPARG(&callarg, value) = value;
4223 	SPARG(&callarg, size) = size;
4224 
4225 	error = rsys_syscall(SYS_fgetxattr, &callarg, sizeof(callarg), retval);
4226 	rsys_seterrno(error);
4227 	if (error == 0) {
4228 		if (sizeof(int) > sizeof(register_t))
4229 			rv = *(int *)retval;
4230 		else
4231 			rv = *retval;
4232 	}
4233 	return rv;
4234 }
4235 #ifdef RUMP_KERNEL_IS_LIBC
4236 __weak_alias(fgetxattr,rump___sysimpl_fgetxattr);
4237 __weak_alias(_fgetxattr,rump___sysimpl_fgetxattr);
4238 __strong_alias(_sys_fgetxattr,rump___sysimpl_fgetxattr);
4239 #endif /* RUMP_KERNEL_IS_LIBC */
4240 
4241 int rump___sysimpl_listxattr(const char *, char *, size_t);
4242 int
4243 rump___sysimpl_listxattr(const char * path, char * list, size_t size)
4244 {
4245 	register_t retval[2];
4246 	int error = 0;
4247 	int rv = -1;
4248 	struct sys_listxattr_args callarg;
4249 
4250 	memset(&callarg, 0, sizeof(callarg));
4251 	SPARG(&callarg, path) = path;
4252 	SPARG(&callarg, list) = list;
4253 	SPARG(&callarg, size) = size;
4254 
4255 	error = rsys_syscall(SYS_listxattr, &callarg, sizeof(callarg), retval);
4256 	rsys_seterrno(error);
4257 	if (error == 0) {
4258 		if (sizeof(int) > sizeof(register_t))
4259 			rv = *(int *)retval;
4260 		else
4261 			rv = *retval;
4262 	}
4263 	return rv;
4264 }
4265 #ifdef RUMP_KERNEL_IS_LIBC
4266 __weak_alias(listxattr,rump___sysimpl_listxattr);
4267 __weak_alias(_listxattr,rump___sysimpl_listxattr);
4268 __strong_alias(_sys_listxattr,rump___sysimpl_listxattr);
4269 #endif /* RUMP_KERNEL_IS_LIBC */
4270 
4271 int rump___sysimpl_llistxattr(const char *, char *, size_t);
4272 int
4273 rump___sysimpl_llistxattr(const char * path, char * list, size_t size)
4274 {
4275 	register_t retval[2];
4276 	int error = 0;
4277 	int rv = -1;
4278 	struct sys_llistxattr_args callarg;
4279 
4280 	memset(&callarg, 0, sizeof(callarg));
4281 	SPARG(&callarg, path) = path;
4282 	SPARG(&callarg, list) = list;
4283 	SPARG(&callarg, size) = size;
4284 
4285 	error = rsys_syscall(SYS_llistxattr, &callarg, sizeof(callarg), retval);
4286 	rsys_seterrno(error);
4287 	if (error == 0) {
4288 		if (sizeof(int) > sizeof(register_t))
4289 			rv = *(int *)retval;
4290 		else
4291 			rv = *retval;
4292 	}
4293 	return rv;
4294 }
4295 #ifdef RUMP_KERNEL_IS_LIBC
4296 __weak_alias(llistxattr,rump___sysimpl_llistxattr);
4297 __weak_alias(_llistxattr,rump___sysimpl_llistxattr);
4298 __strong_alias(_sys_llistxattr,rump___sysimpl_llistxattr);
4299 #endif /* RUMP_KERNEL_IS_LIBC */
4300 
4301 int rump___sysimpl_flistxattr(int, char *, size_t);
4302 int
4303 rump___sysimpl_flistxattr(int fd, char * list, size_t size)
4304 {
4305 	register_t retval[2];
4306 	int error = 0;
4307 	int rv = -1;
4308 	struct sys_flistxattr_args callarg;
4309 
4310 	memset(&callarg, 0, sizeof(callarg));
4311 	SPARG(&callarg, fd) = fd;
4312 	SPARG(&callarg, list) = list;
4313 	SPARG(&callarg, size) = size;
4314 
4315 	error = rsys_syscall(SYS_flistxattr, &callarg, sizeof(callarg), retval);
4316 	rsys_seterrno(error);
4317 	if (error == 0) {
4318 		if (sizeof(int) > sizeof(register_t))
4319 			rv = *(int *)retval;
4320 		else
4321 			rv = *retval;
4322 	}
4323 	return rv;
4324 }
4325 #ifdef RUMP_KERNEL_IS_LIBC
4326 __weak_alias(flistxattr,rump___sysimpl_flistxattr);
4327 __weak_alias(_flistxattr,rump___sysimpl_flistxattr);
4328 __strong_alias(_sys_flistxattr,rump___sysimpl_flistxattr);
4329 #endif /* RUMP_KERNEL_IS_LIBC */
4330 
4331 int rump___sysimpl_removexattr(const char *, const char *);
4332 int
4333 rump___sysimpl_removexattr(const char * path, const char * name)
4334 {
4335 	register_t retval[2];
4336 	int error = 0;
4337 	int rv = -1;
4338 	struct sys_removexattr_args callarg;
4339 
4340 	memset(&callarg, 0, sizeof(callarg));
4341 	SPARG(&callarg, path) = path;
4342 	SPARG(&callarg, name) = name;
4343 
4344 	error = rsys_syscall(SYS_removexattr, &callarg, sizeof(callarg), retval);
4345 	rsys_seterrno(error);
4346 	if (error == 0) {
4347 		if (sizeof(int) > sizeof(register_t))
4348 			rv = *(int *)retval;
4349 		else
4350 			rv = *retval;
4351 	}
4352 	return rv;
4353 }
4354 #ifdef RUMP_KERNEL_IS_LIBC
4355 __weak_alias(removexattr,rump___sysimpl_removexattr);
4356 __weak_alias(_removexattr,rump___sysimpl_removexattr);
4357 __strong_alias(_sys_removexattr,rump___sysimpl_removexattr);
4358 #endif /* RUMP_KERNEL_IS_LIBC */
4359 
4360 int rump___sysimpl_lremovexattr(const char *, const char *);
4361 int
4362 rump___sysimpl_lremovexattr(const char * path, const char * name)
4363 {
4364 	register_t retval[2];
4365 	int error = 0;
4366 	int rv = -1;
4367 	struct sys_lremovexattr_args callarg;
4368 
4369 	memset(&callarg, 0, sizeof(callarg));
4370 	SPARG(&callarg, path) = path;
4371 	SPARG(&callarg, name) = name;
4372 
4373 	error = rsys_syscall(SYS_lremovexattr, &callarg, sizeof(callarg), retval);
4374 	rsys_seterrno(error);
4375 	if (error == 0) {
4376 		if (sizeof(int) > sizeof(register_t))
4377 			rv = *(int *)retval;
4378 		else
4379 			rv = *retval;
4380 	}
4381 	return rv;
4382 }
4383 #ifdef RUMP_KERNEL_IS_LIBC
4384 __weak_alias(lremovexattr,rump___sysimpl_lremovexattr);
4385 __weak_alias(_lremovexattr,rump___sysimpl_lremovexattr);
4386 __strong_alias(_sys_lremovexattr,rump___sysimpl_lremovexattr);
4387 #endif /* RUMP_KERNEL_IS_LIBC */
4388 
4389 int rump___sysimpl_fremovexattr(int, const char *);
4390 int
4391 rump___sysimpl_fremovexattr(int fd, const char * name)
4392 {
4393 	register_t retval[2];
4394 	int error = 0;
4395 	int rv = -1;
4396 	struct sys_fremovexattr_args callarg;
4397 
4398 	memset(&callarg, 0, sizeof(callarg));
4399 	SPARG(&callarg, fd) = fd;
4400 	SPARG(&callarg, name) = name;
4401 
4402 	error = rsys_syscall(SYS_fremovexattr, &callarg, sizeof(callarg), retval);
4403 	rsys_seterrno(error);
4404 	if (error == 0) {
4405 		if (sizeof(int) > sizeof(register_t))
4406 			rv = *(int *)retval;
4407 		else
4408 			rv = *retval;
4409 	}
4410 	return rv;
4411 }
4412 #ifdef RUMP_KERNEL_IS_LIBC
4413 __weak_alias(fremovexattr,rump___sysimpl_fremovexattr);
4414 __weak_alias(_fremovexattr,rump___sysimpl_fremovexattr);
4415 __strong_alias(_sys_fremovexattr,rump___sysimpl_fremovexattr);
4416 #endif /* RUMP_KERNEL_IS_LIBC */
4417 
4418 #ifdef RUMP_SYS_COMPAT
4419 int rump___sysimpl_stat30(const char *, struct stat *);
4420 int
4421 rump___sysimpl_stat30(const char * path, struct stat * ub)
4422 {
4423 	register_t retval[2];
4424 	int error = 0;
4425 	int rv = -1;
4426 	struct compat_50_sys___stat30_args callarg;
4427 
4428 	memset(&callarg, 0, sizeof(callarg));
4429 	SPARG(&callarg, path) = path;
4430 	SPARG(&callarg, ub) = (struct stat30 *)ub;
4431 
4432 	error = rsys_syscall(SYS_compat_50___stat30, &callarg, sizeof(callarg), retval);
4433 	rsys_seterrno(error);
4434 	if (error == 0) {
4435 		if (sizeof(int) > sizeof(register_t))
4436 			rv = *(int *)retval;
4437 		else
4438 			rv = *retval;
4439 	}
4440 	return rv;
4441 }
4442 #ifdef RUMP_KERNEL_IS_LIBC
4443 __weak_alias(stat,rump___sysimpl_stat30);
4444 __weak_alias(__stat30,rump___sysimpl_stat30);
4445 __weak_alias(___stat30,rump___sysimpl_stat30);
4446 __strong_alias(_sys___stat30,rump___sysimpl_stat30);
4447 #endif /* RUMP_KERNEL_IS_LIBC */
4448 #endif /* RUMP_SYS_COMPAT */
4449 
4450 #ifdef RUMP_SYS_COMPAT
4451 int rump___sysimpl_fstat30(int, struct stat *);
4452 int
4453 rump___sysimpl_fstat30(int fd, struct stat * sb)
4454 {
4455 	register_t retval[2];
4456 	int error = 0;
4457 	int rv = -1;
4458 	struct compat_50_sys___fstat30_args callarg;
4459 
4460 	memset(&callarg, 0, sizeof(callarg));
4461 	SPARG(&callarg, fd) = fd;
4462 	SPARG(&callarg, sb) = (struct stat30 *)sb;
4463 
4464 	error = rsys_syscall(SYS_compat_50___fstat30, &callarg, sizeof(callarg), retval);
4465 	rsys_seterrno(error);
4466 	if (error == 0) {
4467 		if (sizeof(int) > sizeof(register_t))
4468 			rv = *(int *)retval;
4469 		else
4470 			rv = *retval;
4471 	}
4472 	return rv;
4473 }
4474 #ifdef RUMP_KERNEL_IS_LIBC
4475 __weak_alias(fstat,rump___sysimpl_fstat30);
4476 __weak_alias(__fstat30,rump___sysimpl_fstat30);
4477 __weak_alias(___fstat30,rump___sysimpl_fstat30);
4478 __strong_alias(_sys___fstat30,rump___sysimpl_fstat30);
4479 #endif /* RUMP_KERNEL_IS_LIBC */
4480 #endif /* RUMP_SYS_COMPAT */
4481 
4482 #ifdef RUMP_SYS_COMPAT
4483 int rump___sysimpl_lstat30(const char *, struct stat *);
4484 int
4485 rump___sysimpl_lstat30(const char * path, struct stat * ub)
4486 {
4487 	register_t retval[2];
4488 	int error = 0;
4489 	int rv = -1;
4490 	struct compat_50_sys___lstat30_args callarg;
4491 
4492 	memset(&callarg, 0, sizeof(callarg));
4493 	SPARG(&callarg, path) = path;
4494 	SPARG(&callarg, ub) = (struct stat30 *)ub;
4495 
4496 	error = rsys_syscall(SYS_compat_50___lstat30, &callarg, sizeof(callarg), retval);
4497 	rsys_seterrno(error);
4498 	if (error == 0) {
4499 		if (sizeof(int) > sizeof(register_t))
4500 			rv = *(int *)retval;
4501 		else
4502 			rv = *retval;
4503 	}
4504 	return rv;
4505 }
4506 #ifdef RUMP_KERNEL_IS_LIBC
4507 __weak_alias(lstat,rump___sysimpl_lstat30);
4508 __weak_alias(__lstat30,rump___sysimpl_lstat30);
4509 __weak_alias(___lstat30,rump___sysimpl_lstat30);
4510 __strong_alias(_sys___lstat30,rump___sysimpl_lstat30);
4511 #endif /* RUMP_KERNEL_IS_LIBC */
4512 #endif /* RUMP_SYS_COMPAT */
4513 
4514 int rump___sysimpl_getdents30(int, char *, size_t);
4515 int
4516 rump___sysimpl_getdents30(int fd, char * buf, size_t count)
4517 {
4518 	register_t retval[2];
4519 	int error = 0;
4520 	int rv = -1;
4521 	struct sys___getdents30_args callarg;
4522 
4523 	memset(&callarg, 0, sizeof(callarg));
4524 	SPARG(&callarg, fd) = fd;
4525 	SPARG(&callarg, buf) = buf;
4526 	SPARG(&callarg, count) = count;
4527 
4528 	error = rsys_syscall(SYS___getdents30, &callarg, sizeof(callarg), retval);
4529 	rsys_seterrno(error);
4530 	if (error == 0) {
4531 		if (sizeof(int) > sizeof(register_t))
4532 			rv = *(int *)retval;
4533 		else
4534 			rv = *retval;
4535 	}
4536 	return rv;
4537 }
4538 #ifdef RUMP_KERNEL_IS_LIBC
4539 __weak_alias(getdents,rump___sysimpl_getdents30);
4540 __weak_alias(__getdents30,rump___sysimpl_getdents30);
4541 __weak_alias(___getdents30,rump___sysimpl_getdents30);
4542 __strong_alias(_sys___getdents30,rump___sysimpl_getdents30);
4543 #endif /* RUMP_KERNEL_IS_LIBC */
4544 
4545 int rump___sysimpl_socket30(int, int, int);
4546 int
4547 rump___sysimpl_socket30(int domain, int type, int protocol)
4548 {
4549 	register_t retval[2];
4550 	int error = 0;
4551 	int rv = -1;
4552 	struct sys___socket30_args callarg;
4553 
4554 	memset(&callarg, 0, sizeof(callarg));
4555 	SPARG(&callarg, domain) = domain;
4556 	SPARG(&callarg, type) = type;
4557 	SPARG(&callarg, protocol) = protocol;
4558 
4559 	error = rsys_syscall(SYS___socket30, &callarg, sizeof(callarg), retval);
4560 	rsys_seterrno(error);
4561 	if (error == 0) {
4562 		if (sizeof(int) > sizeof(register_t))
4563 			rv = *(int *)retval;
4564 		else
4565 			rv = *retval;
4566 	}
4567 	return rv;
4568 }
4569 #ifdef RUMP_KERNEL_IS_LIBC
4570 __weak_alias(socket,rump___sysimpl_socket30);
4571 __weak_alias(__socket30,rump___sysimpl_socket30);
4572 __weak_alias(___socket30,rump___sysimpl_socket30);
4573 __strong_alias(_sys___socket30,rump___sysimpl_socket30);
4574 #endif /* RUMP_KERNEL_IS_LIBC */
4575 
4576 int rump___sysimpl_getfh30(const char *, void *, size_t *);
4577 int
4578 rump___sysimpl_getfh30(const char * fname, void * fhp, size_t * fh_size)
4579 {
4580 	register_t retval[2];
4581 	int error = 0;
4582 	int rv = -1;
4583 	struct sys___getfh30_args callarg;
4584 
4585 	memset(&callarg, 0, sizeof(callarg));
4586 	SPARG(&callarg, fname) = fname;
4587 	SPARG(&callarg, fhp) = fhp;
4588 	SPARG(&callarg, fh_size) = fh_size;
4589 
4590 	error = rsys_syscall(SYS___getfh30, &callarg, sizeof(callarg), retval);
4591 	rsys_seterrno(error);
4592 	if (error == 0) {
4593 		if (sizeof(int) > sizeof(register_t))
4594 			rv = *(int *)retval;
4595 		else
4596 			rv = *retval;
4597 	}
4598 	return rv;
4599 }
4600 #ifdef RUMP_KERNEL_IS_LIBC
4601 __weak_alias(getfh,rump___sysimpl_getfh30);
4602 __weak_alias(__getfh30,rump___sysimpl_getfh30);
4603 __weak_alias(___getfh30,rump___sysimpl_getfh30);
4604 __strong_alias(_sys___getfh30,rump___sysimpl_getfh30);
4605 #endif /* RUMP_KERNEL_IS_LIBC */
4606 
4607 int rump___sysimpl_fhopen40(const void *, size_t, int);
4608 int
4609 rump___sysimpl_fhopen40(const void * fhp, size_t fh_size, int flags)
4610 {
4611 	register_t retval[2];
4612 	int error = 0;
4613 	int rv = -1;
4614 	struct sys___fhopen40_args callarg;
4615 
4616 	memset(&callarg, 0, sizeof(callarg));
4617 	SPARG(&callarg, fhp) = fhp;
4618 	SPARG(&callarg, fh_size) = fh_size;
4619 	SPARG(&callarg, flags) = flags;
4620 
4621 	error = rsys_syscall(SYS___fhopen40, &callarg, sizeof(callarg), retval);
4622 	rsys_seterrno(error);
4623 	if (error == 0) {
4624 		if (sizeof(int) > sizeof(register_t))
4625 			rv = *(int *)retval;
4626 		else
4627 			rv = *retval;
4628 	}
4629 	return rv;
4630 }
4631 #ifdef RUMP_KERNEL_IS_LIBC
4632 __weak_alias(fhopen,rump___sysimpl_fhopen40);
4633 __weak_alias(__fhopen40,rump___sysimpl_fhopen40);
4634 __weak_alias(___fhopen40,rump___sysimpl_fhopen40);
4635 __strong_alias(_sys___fhopen40,rump___sysimpl_fhopen40);
4636 #endif /* RUMP_KERNEL_IS_LIBC */
4637 
4638 #ifdef RUMP_SYS_COMPAT
4639 int rump___sysimpl_fhstat40(const void *, size_t, struct stat *);
4640 int
4641 rump___sysimpl_fhstat40(const void * fhp, size_t fh_size, struct stat * sb)
4642 {
4643 	register_t retval[2];
4644 	int error = 0;
4645 	int rv = -1;
4646 	struct compat_50_sys___fhstat40_args callarg;
4647 
4648 	memset(&callarg, 0, sizeof(callarg));
4649 	SPARG(&callarg, fhp) = fhp;
4650 	SPARG(&callarg, fh_size) = fh_size;
4651 	SPARG(&callarg, sb) = (struct stat30 *)sb;
4652 
4653 	error = rsys_syscall(SYS_compat_50___fhstat40, &callarg, sizeof(callarg), retval);
4654 	rsys_seterrno(error);
4655 	if (error == 0) {
4656 		if (sizeof(int) > sizeof(register_t))
4657 			rv = *(int *)retval;
4658 		else
4659 			rv = *retval;
4660 	}
4661 	return rv;
4662 }
4663 #ifdef RUMP_KERNEL_IS_LIBC
4664 __weak_alias(fhstat,rump___sysimpl_fhstat40);
4665 __weak_alias(__fhstat40,rump___sysimpl_fhstat40);
4666 __weak_alias(___fhstat40,rump___sysimpl_fhstat40);
4667 __strong_alias(_sys___fhstat40,rump___sysimpl_fhstat40);
4668 #endif /* RUMP_KERNEL_IS_LIBC */
4669 #endif /* RUMP_SYS_COMPAT */
4670 
4671 int rump___sysimpl_aio_cancel(int, struct aiocb *);
4672 int
4673 rump___sysimpl_aio_cancel(int fildes, struct aiocb * aiocbp)
4674 {
4675 	register_t retval[2];
4676 	int error = 0;
4677 	int rv = -1;
4678 	struct sys_aio_cancel_args callarg;
4679 
4680 	memset(&callarg, 0, sizeof(callarg));
4681 	SPARG(&callarg, fildes) = fildes;
4682 	SPARG(&callarg, aiocbp) = aiocbp;
4683 
4684 	error = rsys_syscall(SYS_aio_cancel, &callarg, sizeof(callarg), retval);
4685 	rsys_seterrno(error);
4686 	if (error == 0) {
4687 		if (sizeof(int) > sizeof(register_t))
4688 			rv = *(int *)retval;
4689 		else
4690 			rv = *retval;
4691 	}
4692 	return rv;
4693 }
4694 #ifdef RUMP_KERNEL_IS_LIBC
4695 __weak_alias(aio_cancel,rump___sysimpl_aio_cancel);
4696 __weak_alias(_aio_cancel,rump___sysimpl_aio_cancel);
4697 __strong_alias(_sys_aio_cancel,rump___sysimpl_aio_cancel);
4698 #endif /* RUMP_KERNEL_IS_LIBC */
4699 
4700 int rump___sysimpl_aio_error(const struct aiocb *);
4701 int
4702 rump___sysimpl_aio_error(const struct aiocb * aiocbp)
4703 {
4704 	register_t retval[2];
4705 	int error = 0;
4706 	int rv = -1;
4707 	struct sys_aio_error_args callarg;
4708 
4709 	memset(&callarg, 0, sizeof(callarg));
4710 	SPARG(&callarg, aiocbp) = aiocbp;
4711 
4712 	error = rsys_syscall(SYS_aio_error, &callarg, sizeof(callarg), retval);
4713 	rsys_seterrno(error);
4714 	if (error == 0) {
4715 		if (sizeof(int) > sizeof(register_t))
4716 			rv = *(int *)retval;
4717 		else
4718 			rv = *retval;
4719 	}
4720 	return rv;
4721 }
4722 #ifdef RUMP_KERNEL_IS_LIBC
4723 __weak_alias(aio_error,rump___sysimpl_aio_error);
4724 __weak_alias(_aio_error,rump___sysimpl_aio_error);
4725 __strong_alias(_sys_aio_error,rump___sysimpl_aio_error);
4726 #endif /* RUMP_KERNEL_IS_LIBC */
4727 
4728 int rump___sysimpl_aio_fsync(int, struct aiocb *);
4729 int
4730 rump___sysimpl_aio_fsync(int op, struct aiocb * aiocbp)
4731 {
4732 	register_t retval[2];
4733 	int error = 0;
4734 	int rv = -1;
4735 	struct sys_aio_fsync_args callarg;
4736 
4737 	memset(&callarg, 0, sizeof(callarg));
4738 	SPARG(&callarg, op) = op;
4739 	SPARG(&callarg, aiocbp) = aiocbp;
4740 
4741 	error = rsys_syscall(SYS_aio_fsync, &callarg, sizeof(callarg), retval);
4742 	rsys_seterrno(error);
4743 	if (error == 0) {
4744 		if (sizeof(int) > sizeof(register_t))
4745 			rv = *(int *)retval;
4746 		else
4747 			rv = *retval;
4748 	}
4749 	return rv;
4750 }
4751 #ifdef RUMP_KERNEL_IS_LIBC
4752 __weak_alias(aio_fsync,rump___sysimpl_aio_fsync);
4753 __weak_alias(_aio_fsync,rump___sysimpl_aio_fsync);
4754 __strong_alias(_sys_aio_fsync,rump___sysimpl_aio_fsync);
4755 #endif /* RUMP_KERNEL_IS_LIBC */
4756 
4757 int rump___sysimpl_aio_read(struct aiocb *);
4758 int
4759 rump___sysimpl_aio_read(struct aiocb * aiocbp)
4760 {
4761 	register_t retval[2];
4762 	int error = 0;
4763 	int rv = -1;
4764 	struct sys_aio_read_args callarg;
4765 
4766 	memset(&callarg, 0, sizeof(callarg));
4767 	SPARG(&callarg, aiocbp) = aiocbp;
4768 
4769 	error = rsys_syscall(SYS_aio_read, &callarg, sizeof(callarg), retval);
4770 	rsys_seterrno(error);
4771 	if (error == 0) {
4772 		if (sizeof(int) > sizeof(register_t))
4773 			rv = *(int *)retval;
4774 		else
4775 			rv = *retval;
4776 	}
4777 	return rv;
4778 }
4779 #ifdef RUMP_KERNEL_IS_LIBC
4780 __weak_alias(aio_read,rump___sysimpl_aio_read);
4781 __weak_alias(_aio_read,rump___sysimpl_aio_read);
4782 __strong_alias(_sys_aio_read,rump___sysimpl_aio_read);
4783 #endif /* RUMP_KERNEL_IS_LIBC */
4784 
4785 int rump___sysimpl_aio_return(struct aiocb *);
4786 int
4787 rump___sysimpl_aio_return(struct aiocb * aiocbp)
4788 {
4789 	register_t retval[2];
4790 	int error = 0;
4791 	int rv = -1;
4792 	struct sys_aio_return_args callarg;
4793 
4794 	memset(&callarg, 0, sizeof(callarg));
4795 	SPARG(&callarg, aiocbp) = aiocbp;
4796 
4797 	error = rsys_syscall(SYS_aio_return, &callarg, sizeof(callarg), retval);
4798 	rsys_seterrno(error);
4799 	if (error == 0) {
4800 		if (sizeof(int) > sizeof(register_t))
4801 			rv = *(int *)retval;
4802 		else
4803 			rv = *retval;
4804 	}
4805 	return rv;
4806 }
4807 #ifdef RUMP_KERNEL_IS_LIBC
4808 __weak_alias(aio_return,rump___sysimpl_aio_return);
4809 __weak_alias(_aio_return,rump___sysimpl_aio_return);
4810 __strong_alias(_sys_aio_return,rump___sysimpl_aio_return);
4811 #endif /* RUMP_KERNEL_IS_LIBC */
4812 
4813 int rump___sysimpl_aio_write(struct aiocb *);
4814 int
4815 rump___sysimpl_aio_write(struct aiocb * aiocbp)
4816 {
4817 	register_t retval[2];
4818 	int error = 0;
4819 	int rv = -1;
4820 	struct sys_aio_write_args callarg;
4821 
4822 	memset(&callarg, 0, sizeof(callarg));
4823 	SPARG(&callarg, aiocbp) = aiocbp;
4824 
4825 	error = rsys_syscall(SYS_aio_write, &callarg, sizeof(callarg), retval);
4826 	rsys_seterrno(error);
4827 	if (error == 0) {
4828 		if (sizeof(int) > sizeof(register_t))
4829 			rv = *(int *)retval;
4830 		else
4831 			rv = *retval;
4832 	}
4833 	return rv;
4834 }
4835 #ifdef RUMP_KERNEL_IS_LIBC
4836 __weak_alias(aio_write,rump___sysimpl_aio_write);
4837 __weak_alias(_aio_write,rump___sysimpl_aio_write);
4838 __strong_alias(_sys_aio_write,rump___sysimpl_aio_write);
4839 #endif /* RUMP_KERNEL_IS_LIBC */
4840 
4841 int rump___sysimpl_lio_listio(int, struct aiocb *const *, int, struct sigevent *);
4842 int
4843 rump___sysimpl_lio_listio(int mode, struct aiocb *const * list, int nent, struct sigevent * sig)
4844 {
4845 	register_t retval[2];
4846 	int error = 0;
4847 	int rv = -1;
4848 	struct sys_lio_listio_args callarg;
4849 
4850 	memset(&callarg, 0, sizeof(callarg));
4851 	SPARG(&callarg, mode) = mode;
4852 	SPARG(&callarg, list) = list;
4853 	SPARG(&callarg, nent) = nent;
4854 	SPARG(&callarg, sig) = sig;
4855 
4856 	error = rsys_syscall(SYS_lio_listio, &callarg, sizeof(callarg), retval);
4857 	rsys_seterrno(error);
4858 	if (error == 0) {
4859 		if (sizeof(int) > sizeof(register_t))
4860 			rv = *(int *)retval;
4861 		else
4862 			rv = *retval;
4863 	}
4864 	return rv;
4865 }
4866 #ifdef RUMP_KERNEL_IS_LIBC
4867 __weak_alias(lio_listio,rump___sysimpl_lio_listio);
4868 __weak_alias(_lio_listio,rump___sysimpl_lio_listio);
4869 __strong_alias(_sys_lio_listio,rump___sysimpl_lio_listio);
4870 #endif /* RUMP_KERNEL_IS_LIBC */
4871 
4872 int rump___sysimpl_mount50(const char *, const char *, int, void *, size_t);
4873 int
4874 rump___sysimpl_mount50(const char * type, const char * path, int flags, void * data, size_t data_len)
4875 {
4876 	register_t retval[2];
4877 	int error = 0;
4878 	int rv = -1;
4879 	struct sys___mount50_args callarg;
4880 
4881 	memset(&callarg, 0, sizeof(callarg));
4882 	SPARG(&callarg, type) = type;
4883 	SPARG(&callarg, path) = path;
4884 	SPARG(&callarg, flags) = flags;
4885 	SPARG(&callarg, data) = data;
4886 	SPARG(&callarg, data_len) = data_len;
4887 
4888 	error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), retval);
4889 	rsys_seterrno(error);
4890 	if (error == 0) {
4891 		if (sizeof(int) > sizeof(register_t))
4892 			rv = *(int *)retval;
4893 		else
4894 			rv = *retval;
4895 	}
4896 	return rv;
4897 }
4898 #ifdef RUMP_KERNEL_IS_LIBC
4899 __weak_alias(mount,rump___sysimpl_mount50);
4900 __weak_alias(__mount50,rump___sysimpl_mount50);
4901 __weak_alias(___mount50,rump___sysimpl_mount50);
4902 __strong_alias(_sys___mount50,rump___sysimpl_mount50);
4903 #endif /* RUMP_KERNEL_IS_LIBC */
4904 
4905 int rump___sysimpl_posix_fadvise50(int, off_t, off_t, int);
4906 int
4907 rump___sysimpl_posix_fadvise50(int fd, off_t offset, off_t len, int advice)
4908 {
4909 	register_t retval[2];
4910 	int rv = -1;
4911 	struct sys___posix_fadvise50_args callarg;
4912 
4913 	memset(&callarg, 0, sizeof(callarg));
4914 	SPARG(&callarg, fd) = fd;
4915 	SPARG(&callarg, PAD) = 0;
4916 	SPARG(&callarg, offset) = offset;
4917 	SPARG(&callarg, len) = len;
4918 	SPARG(&callarg, advice) = advice;
4919 
4920 	(void)rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), retval);
4921 	if (sizeof(int) > sizeof(register_t))
4922 		rv = *(int *)retval;
4923 	else
4924 		rv = *retval;
4925 	return rv;
4926 }
4927 #ifdef RUMP_KERNEL_IS_LIBC
4928 __weak_alias(posix_fadvise,rump___sysimpl_posix_fadvise50);
4929 __weak_alias(__posix_fadvise50,rump___sysimpl_posix_fadvise50);
4930 __weak_alias(___posix_fadvise50,rump___sysimpl_posix_fadvise50);
4931 __strong_alias(_sys___posix_fadvise50,rump___sysimpl_posix_fadvise50);
4932 #endif /* RUMP_KERNEL_IS_LIBC */
4933 
4934 int rump___sysimpl_select50(int, fd_set *, fd_set *, fd_set *, struct timeval *);
4935 int
4936 rump___sysimpl_select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv)
4937 {
4938 	register_t retval[2];
4939 	int error = 0;
4940 	int rv = -1;
4941 	struct sys___select50_args callarg;
4942 
4943 	memset(&callarg, 0, sizeof(callarg));
4944 	SPARG(&callarg, nd) = nd;
4945 	SPARG(&callarg, in) = in;
4946 	SPARG(&callarg, ou) = ou;
4947 	SPARG(&callarg, ex) = ex;
4948 	SPARG(&callarg, tv) = tv;
4949 
4950 	error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), retval);
4951 	rsys_seterrno(error);
4952 	if (error == 0) {
4953 		if (sizeof(int) > sizeof(register_t))
4954 			rv = *(int *)retval;
4955 		else
4956 			rv = *retval;
4957 	}
4958 	return rv;
4959 }
4960 #ifdef RUMP_KERNEL_IS_LIBC
4961 __weak_alias(select,rump___sysimpl_select50);
4962 __weak_alias(__select50,rump___sysimpl_select50);
4963 __weak_alias(___select50,rump___sysimpl_select50);
4964 __strong_alias(_sys___select50,rump___sysimpl_select50);
4965 #endif /* RUMP_KERNEL_IS_LIBC */
4966 
4967 int rump___sysimpl_gettimeofday50(struct timeval *, void *);
4968 int
4969 rump___sysimpl_gettimeofday50(struct timeval * tp, void * tzp)
4970 {
4971 	register_t retval[2];
4972 	int error = 0;
4973 	int rv = -1;
4974 	struct sys___gettimeofday50_args callarg;
4975 
4976 	memset(&callarg, 0, sizeof(callarg));
4977 	SPARG(&callarg, tp) = tp;
4978 	SPARG(&callarg, tzp) = tzp;
4979 
4980 	error = rsys_syscall(SYS___gettimeofday50, &callarg, sizeof(callarg), retval);
4981 	rsys_seterrno(error);
4982 	if (error == 0) {
4983 		if (sizeof(int) > sizeof(register_t))
4984 			rv = *(int *)retval;
4985 		else
4986 			rv = *retval;
4987 	}
4988 	return rv;
4989 }
4990 #ifdef RUMP_KERNEL_IS_LIBC
4991 __weak_alias(gettimeofday,rump___sysimpl_gettimeofday50);
4992 __weak_alias(__gettimeofday50,rump___sysimpl_gettimeofday50);
4993 __weak_alias(___gettimeofday50,rump___sysimpl_gettimeofday50);
4994 __strong_alias(_sys___gettimeofday50,rump___sysimpl_gettimeofday50);
4995 #endif /* RUMP_KERNEL_IS_LIBC */
4996 
4997 int rump___sysimpl_settimeofday50(const struct timeval *, const void *);
4998 int
4999 rump___sysimpl_settimeofday50(const struct timeval * tv, const void * tzp)
5000 {
5001 	register_t retval[2];
5002 	int error = 0;
5003 	int rv = -1;
5004 	struct sys___settimeofday50_args callarg;
5005 
5006 	memset(&callarg, 0, sizeof(callarg));
5007 	SPARG(&callarg, tv) = tv;
5008 	SPARG(&callarg, tzp) = tzp;
5009 
5010 	error = rsys_syscall(SYS___settimeofday50, &callarg, sizeof(callarg), retval);
5011 	rsys_seterrno(error);
5012 	if (error == 0) {
5013 		if (sizeof(int) > sizeof(register_t))
5014 			rv = *(int *)retval;
5015 		else
5016 			rv = *retval;
5017 	}
5018 	return rv;
5019 }
5020 #ifdef RUMP_KERNEL_IS_LIBC
5021 __weak_alias(settimeofday,rump___sysimpl_settimeofday50);
5022 __weak_alias(__settimeofday50,rump___sysimpl_settimeofday50);
5023 __weak_alias(___settimeofday50,rump___sysimpl_settimeofday50);
5024 __strong_alias(_sys___settimeofday50,rump___sysimpl_settimeofday50);
5025 #endif /* RUMP_KERNEL_IS_LIBC */
5026 
5027 int rump___sysimpl_utimes50(const char *, const struct timeval *);
5028 int
5029 rump___sysimpl_utimes50(const char * path, const struct timeval * tptr)
5030 {
5031 	register_t retval[2];
5032 	int error = 0;
5033 	int rv = -1;
5034 	struct sys___utimes50_args callarg;
5035 
5036 	memset(&callarg, 0, sizeof(callarg));
5037 	SPARG(&callarg, path) = path;
5038 	SPARG(&callarg, tptr) = tptr;
5039 
5040 	error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), retval);
5041 	rsys_seterrno(error);
5042 	if (error == 0) {
5043 		if (sizeof(int) > sizeof(register_t))
5044 			rv = *(int *)retval;
5045 		else
5046 			rv = *retval;
5047 	}
5048 	return rv;
5049 }
5050 #ifdef RUMP_KERNEL_IS_LIBC
5051 __weak_alias(utimes,rump___sysimpl_utimes50);
5052 __weak_alias(__utimes50,rump___sysimpl_utimes50);
5053 __weak_alias(___utimes50,rump___sysimpl_utimes50);
5054 __strong_alias(_sys___utimes50,rump___sysimpl_utimes50);
5055 #endif /* RUMP_KERNEL_IS_LIBC */
5056 
5057 int rump___sysimpl_adjtime50(const struct timeval *, struct timeval *);
5058 int
5059 rump___sysimpl_adjtime50(const struct timeval * delta, struct timeval * olddelta)
5060 {
5061 	register_t retval[2];
5062 	int error = 0;
5063 	int rv = -1;
5064 	struct sys___adjtime50_args callarg;
5065 
5066 	memset(&callarg, 0, sizeof(callarg));
5067 	SPARG(&callarg, delta) = delta;
5068 	SPARG(&callarg, olddelta) = olddelta;
5069 
5070 	error = rsys_syscall(SYS___adjtime50, &callarg, sizeof(callarg), retval);
5071 	rsys_seterrno(error);
5072 	if (error == 0) {
5073 		if (sizeof(int) > sizeof(register_t))
5074 			rv = *(int *)retval;
5075 		else
5076 			rv = *retval;
5077 	}
5078 	return rv;
5079 }
5080 #ifdef RUMP_KERNEL_IS_LIBC
5081 __weak_alias(adjtime,rump___sysimpl_adjtime50);
5082 __weak_alias(__adjtime50,rump___sysimpl_adjtime50);
5083 __weak_alias(___adjtime50,rump___sysimpl_adjtime50);
5084 __strong_alias(_sys___adjtime50,rump___sysimpl_adjtime50);
5085 #endif /* RUMP_KERNEL_IS_LIBC */
5086 
5087 int rump___sysimpl_futimes50(int, const struct timeval *);
5088 int
5089 rump___sysimpl_futimes50(int fd, const struct timeval * tptr)
5090 {
5091 	register_t retval[2];
5092 	int error = 0;
5093 	int rv = -1;
5094 	struct sys___futimes50_args callarg;
5095 
5096 	memset(&callarg, 0, sizeof(callarg));
5097 	SPARG(&callarg, fd) = fd;
5098 	SPARG(&callarg, tptr) = tptr;
5099 
5100 	error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), retval);
5101 	rsys_seterrno(error);
5102 	if (error == 0) {
5103 		if (sizeof(int) > sizeof(register_t))
5104 			rv = *(int *)retval;
5105 		else
5106 			rv = *retval;
5107 	}
5108 	return rv;
5109 }
5110 #ifdef RUMP_KERNEL_IS_LIBC
5111 __weak_alias(futimes,rump___sysimpl_futimes50);
5112 __weak_alias(__futimes50,rump___sysimpl_futimes50);
5113 __weak_alias(___futimes50,rump___sysimpl_futimes50);
5114 __strong_alias(_sys___futimes50,rump___sysimpl_futimes50);
5115 #endif /* RUMP_KERNEL_IS_LIBC */
5116 
5117 int rump___sysimpl_lutimes50(const char *, const struct timeval *);
5118 int
5119 rump___sysimpl_lutimes50(const char * path, const struct timeval * tptr)
5120 {
5121 	register_t retval[2];
5122 	int error = 0;
5123 	int rv = -1;
5124 	struct sys___lutimes50_args callarg;
5125 
5126 	memset(&callarg, 0, sizeof(callarg));
5127 	SPARG(&callarg, path) = path;
5128 	SPARG(&callarg, tptr) = tptr;
5129 
5130 	error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), retval);
5131 	rsys_seterrno(error);
5132 	if (error == 0) {
5133 		if (sizeof(int) > sizeof(register_t))
5134 			rv = *(int *)retval;
5135 		else
5136 			rv = *retval;
5137 	}
5138 	return rv;
5139 }
5140 #ifdef RUMP_KERNEL_IS_LIBC
5141 __weak_alias(lutimes,rump___sysimpl_lutimes50);
5142 __weak_alias(__lutimes50,rump___sysimpl_lutimes50);
5143 __weak_alias(___lutimes50,rump___sysimpl_lutimes50);
5144 __strong_alias(_sys___lutimes50,rump___sysimpl_lutimes50);
5145 #endif /* RUMP_KERNEL_IS_LIBC */
5146 
5147 int rump___sysimpl_setitimer50(int, const struct itimerval *, struct itimerval *);
5148 int
5149 rump___sysimpl_setitimer50(int which, const struct itimerval * itv, struct itimerval * oitv)
5150 {
5151 	register_t retval[2];
5152 	int error = 0;
5153 	int rv = -1;
5154 	struct sys___setitimer50_args callarg;
5155 
5156 	memset(&callarg, 0, sizeof(callarg));
5157 	SPARG(&callarg, which) = which;
5158 	SPARG(&callarg, itv) = itv;
5159 	SPARG(&callarg, oitv) = oitv;
5160 
5161 	error = rsys_syscall(SYS___setitimer50, &callarg, sizeof(callarg), retval);
5162 	rsys_seterrno(error);
5163 	if (error == 0) {
5164 		if (sizeof(int) > sizeof(register_t))
5165 			rv = *(int *)retval;
5166 		else
5167 			rv = *retval;
5168 	}
5169 	return rv;
5170 }
5171 #ifdef RUMP_KERNEL_IS_LIBC
5172 __weak_alias(setitimer,rump___sysimpl_setitimer50);
5173 __weak_alias(__setitimer50,rump___sysimpl_setitimer50);
5174 __weak_alias(___setitimer50,rump___sysimpl_setitimer50);
5175 __strong_alias(_sys___setitimer50,rump___sysimpl_setitimer50);
5176 #endif /* RUMP_KERNEL_IS_LIBC */
5177 
5178 int rump___sysimpl_getitimer50(int, struct itimerval *);
5179 int
5180 rump___sysimpl_getitimer50(int which, struct itimerval * itv)
5181 {
5182 	register_t retval[2];
5183 	int error = 0;
5184 	int rv = -1;
5185 	struct sys___getitimer50_args callarg;
5186 
5187 	memset(&callarg, 0, sizeof(callarg));
5188 	SPARG(&callarg, which) = which;
5189 	SPARG(&callarg, itv) = itv;
5190 
5191 	error = rsys_syscall(SYS___getitimer50, &callarg, sizeof(callarg), retval);
5192 	rsys_seterrno(error);
5193 	if (error == 0) {
5194 		if (sizeof(int) > sizeof(register_t))
5195 			rv = *(int *)retval;
5196 		else
5197 			rv = *retval;
5198 	}
5199 	return rv;
5200 }
5201 #ifdef RUMP_KERNEL_IS_LIBC
5202 __weak_alias(getitimer,rump___sysimpl_getitimer50);
5203 __weak_alias(__getitimer50,rump___sysimpl_getitimer50);
5204 __weak_alias(___getitimer50,rump___sysimpl_getitimer50);
5205 __strong_alias(_sys___getitimer50,rump___sysimpl_getitimer50);
5206 #endif /* RUMP_KERNEL_IS_LIBC */
5207 
5208 int rump___sysimpl_clock_gettime50(clockid_t, struct timespec *);
5209 int
5210 rump___sysimpl_clock_gettime50(clockid_t clock_id, struct timespec * tp)
5211 {
5212 	register_t retval[2];
5213 	int error = 0;
5214 	int rv = -1;
5215 	struct sys___clock_gettime50_args callarg;
5216 
5217 	memset(&callarg, 0, sizeof(callarg));
5218 	SPARG(&callarg, clock_id) = clock_id;
5219 	SPARG(&callarg, tp) = tp;
5220 
5221 	error = rsys_syscall(SYS___clock_gettime50, &callarg, sizeof(callarg), retval);
5222 	rsys_seterrno(error);
5223 	if (error == 0) {
5224 		if (sizeof(int) > sizeof(register_t))
5225 			rv = *(int *)retval;
5226 		else
5227 			rv = *retval;
5228 	}
5229 	return rv;
5230 }
5231 #ifdef RUMP_KERNEL_IS_LIBC
5232 __weak_alias(clock_gettime,rump___sysimpl_clock_gettime50);
5233 __weak_alias(__clock_gettime50,rump___sysimpl_clock_gettime50);
5234 __weak_alias(___clock_gettime50,rump___sysimpl_clock_gettime50);
5235 __strong_alias(_sys___clock_gettime50,rump___sysimpl_clock_gettime50);
5236 #endif /* RUMP_KERNEL_IS_LIBC */
5237 
5238 int rump___sysimpl_clock_settime50(clockid_t, const struct timespec *);
5239 int
5240 rump___sysimpl_clock_settime50(clockid_t clock_id, const struct timespec * tp)
5241 {
5242 	register_t retval[2];
5243 	int error = 0;
5244 	int rv = -1;
5245 	struct sys___clock_settime50_args callarg;
5246 
5247 	memset(&callarg, 0, sizeof(callarg));
5248 	SPARG(&callarg, clock_id) = clock_id;
5249 	SPARG(&callarg, tp) = tp;
5250 
5251 	error = rsys_syscall(SYS___clock_settime50, &callarg, sizeof(callarg), retval);
5252 	rsys_seterrno(error);
5253 	if (error == 0) {
5254 		if (sizeof(int) > sizeof(register_t))
5255 			rv = *(int *)retval;
5256 		else
5257 			rv = *retval;
5258 	}
5259 	return rv;
5260 }
5261 #ifdef RUMP_KERNEL_IS_LIBC
5262 __weak_alias(clock_settime,rump___sysimpl_clock_settime50);
5263 __weak_alias(__clock_settime50,rump___sysimpl_clock_settime50);
5264 __weak_alias(___clock_settime50,rump___sysimpl_clock_settime50);
5265 __strong_alias(_sys___clock_settime50,rump___sysimpl_clock_settime50);
5266 #endif /* RUMP_KERNEL_IS_LIBC */
5267 
5268 int rump___sysimpl_clock_getres50(clockid_t, struct timespec *);
5269 int
5270 rump___sysimpl_clock_getres50(clockid_t clock_id, struct timespec * tp)
5271 {
5272 	register_t retval[2];
5273 	int error = 0;
5274 	int rv = -1;
5275 	struct sys___clock_getres50_args callarg;
5276 
5277 	memset(&callarg, 0, sizeof(callarg));
5278 	SPARG(&callarg, clock_id) = clock_id;
5279 	SPARG(&callarg, tp) = tp;
5280 
5281 	error = rsys_syscall(SYS___clock_getres50, &callarg, sizeof(callarg), retval);
5282 	rsys_seterrno(error);
5283 	if (error == 0) {
5284 		if (sizeof(int) > sizeof(register_t))
5285 			rv = *(int *)retval;
5286 		else
5287 			rv = *retval;
5288 	}
5289 	return rv;
5290 }
5291 #ifdef RUMP_KERNEL_IS_LIBC
5292 __weak_alias(clock_getres,rump___sysimpl_clock_getres50);
5293 __weak_alias(__clock_getres50,rump___sysimpl_clock_getres50);
5294 __weak_alias(___clock_getres50,rump___sysimpl_clock_getres50);
5295 __strong_alias(_sys___clock_getres50,rump___sysimpl_clock_getres50);
5296 #endif /* RUMP_KERNEL_IS_LIBC */
5297 
5298 int rump___sysimpl_nanosleep50(const struct timespec *, struct timespec *);
5299 int
5300 rump___sysimpl_nanosleep50(const struct timespec * rqtp, struct timespec * rmtp)
5301 {
5302 	register_t retval[2];
5303 	int error = 0;
5304 	int rv = -1;
5305 	struct sys___nanosleep50_args callarg;
5306 
5307 	memset(&callarg, 0, sizeof(callarg));
5308 	SPARG(&callarg, rqtp) = rqtp;
5309 	SPARG(&callarg, rmtp) = rmtp;
5310 
5311 	error = rsys_syscall(SYS___nanosleep50, &callarg, sizeof(callarg), retval);
5312 	rsys_seterrno(error);
5313 	if (error == 0) {
5314 		if (sizeof(int) > sizeof(register_t))
5315 			rv = *(int *)retval;
5316 		else
5317 			rv = *retval;
5318 	}
5319 	return rv;
5320 }
5321 #ifdef RUMP_KERNEL_IS_LIBC
5322 __weak_alias(nanosleep,rump___sysimpl_nanosleep50);
5323 __weak_alias(__nanosleep50,rump___sysimpl_nanosleep50);
5324 __weak_alias(___nanosleep50,rump___sysimpl_nanosleep50);
5325 __strong_alias(_sys___nanosleep50,rump___sysimpl_nanosleep50);
5326 #endif /* RUMP_KERNEL_IS_LIBC */
5327 
5328 #ifdef RUMP_SYS_COMPAT
5329 int rump___sysimpl_kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *);
5330 int
5331 rump___sysimpl_kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout)
5332 {
5333 	register_t retval[2];
5334 	int error = 0;
5335 	int rv = -1;
5336 	struct compat_100_sys___kevent50_args callarg;
5337 
5338 	memset(&callarg, 0, sizeof(callarg));
5339 	SPARG(&callarg, fd) = fd;
5340 	SPARG(&callarg, changelist) = (const struct kevent100 *)changelist;
5341 	SPARG(&callarg, nchanges) = nchanges;
5342 	SPARG(&callarg, eventlist) = (struct kevent100 *)eventlist;
5343 	SPARG(&callarg, nevents) = nevents;
5344 	SPARG(&callarg, timeout) = timeout;
5345 
5346 	error = rsys_syscall(SYS_compat_100___kevent50, &callarg, sizeof(callarg), retval);
5347 	rsys_seterrno(error);
5348 	if (error == 0) {
5349 		if (sizeof(int) > sizeof(register_t))
5350 			rv = *(int *)retval;
5351 		else
5352 			rv = *retval;
5353 	}
5354 	return rv;
5355 }
5356 #ifdef RUMP_KERNEL_IS_LIBC
5357 __weak_alias(kevent,rump___sysimpl_kevent50);
5358 __weak_alias(__kevent50,rump___sysimpl_kevent50);
5359 __weak_alias(___kevent50,rump___sysimpl_kevent50);
5360 __strong_alias(_sys___kevent50,rump___sysimpl_kevent50);
5361 #endif /* RUMP_KERNEL_IS_LIBC */
5362 #endif /* RUMP_SYS_COMPAT */
5363 
5364 int rump___sysimpl_pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);
5365 int
5366 rump___sysimpl_pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask)
5367 {
5368 	register_t retval[2];
5369 	int error = 0;
5370 	int rv = -1;
5371 	struct sys___pselect50_args callarg;
5372 
5373 	memset(&callarg, 0, sizeof(callarg));
5374 	SPARG(&callarg, nd) = nd;
5375 	SPARG(&callarg, in) = in;
5376 	SPARG(&callarg, ou) = ou;
5377 	SPARG(&callarg, ex) = ex;
5378 	SPARG(&callarg, ts) = ts;
5379 	SPARG(&callarg, mask) = mask;
5380 
5381 	error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), retval);
5382 	rsys_seterrno(error);
5383 	if (error == 0) {
5384 		if (sizeof(int) > sizeof(register_t))
5385 			rv = *(int *)retval;
5386 		else
5387 			rv = *retval;
5388 	}
5389 	return rv;
5390 }
5391 #ifdef RUMP_KERNEL_IS_LIBC
5392 __weak_alias(pselect,rump___sysimpl_pselect50);
5393 __weak_alias(__pselect50,rump___sysimpl_pselect50);
5394 __weak_alias(___pselect50,rump___sysimpl_pselect50);
5395 __strong_alias(_sys___pselect50,rump___sysimpl_pselect50);
5396 #endif /* RUMP_KERNEL_IS_LIBC */
5397 
5398 int rump___sysimpl_pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *);
5399 int
5400 rump___sysimpl_pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask)
5401 {
5402 	register_t retval[2];
5403 	int error = 0;
5404 	int rv = -1;
5405 	struct sys___pollts50_args callarg;
5406 
5407 	memset(&callarg, 0, sizeof(callarg));
5408 	SPARG(&callarg, fds) = fds;
5409 	SPARG(&callarg, nfds) = nfds;
5410 	SPARG(&callarg, ts) = ts;
5411 	SPARG(&callarg, mask) = mask;
5412 
5413 	error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), retval);
5414 	rsys_seterrno(error);
5415 	if (error == 0) {
5416 		if (sizeof(int) > sizeof(register_t))
5417 			rv = *(int *)retval;
5418 		else
5419 			rv = *retval;
5420 	}
5421 	return rv;
5422 }
5423 #ifdef RUMP_KERNEL_IS_LIBC
5424 __weak_alias(pollts,rump___sysimpl_pollts50);
5425 __weak_alias(__pollts50,rump___sysimpl_pollts50);
5426 __weak_alias(___pollts50,rump___sysimpl_pollts50);
5427 __strong_alias(_sys___pollts50,rump___sysimpl_pollts50);
5428 #endif /* RUMP_KERNEL_IS_LIBC */
5429 
5430 int rump___sysimpl_aio_suspend50(const struct aiocb *const *, int, const struct timespec *);
5431 int
5432 rump___sysimpl_aio_suspend50(const struct aiocb *const * list, int nent, const struct timespec * timeout)
5433 {
5434 	register_t retval[2];
5435 	int error = 0;
5436 	int rv = -1;
5437 	struct sys___aio_suspend50_args callarg;
5438 
5439 	memset(&callarg, 0, sizeof(callarg));
5440 	SPARG(&callarg, list) = list;
5441 	SPARG(&callarg, nent) = nent;
5442 	SPARG(&callarg, timeout) = timeout;
5443 
5444 	error = rsys_syscall(SYS___aio_suspend50, &callarg, sizeof(callarg), retval);
5445 	rsys_seterrno(error);
5446 	if (error == 0) {
5447 		if (sizeof(int) > sizeof(register_t))
5448 			rv = *(int *)retval;
5449 		else
5450 			rv = *retval;
5451 	}
5452 	return rv;
5453 }
5454 #ifdef RUMP_KERNEL_IS_LIBC
5455 __weak_alias(aio_suspend,rump___sysimpl_aio_suspend50);
5456 __weak_alias(__aio_suspend50,rump___sysimpl_aio_suspend50);
5457 __weak_alias(___aio_suspend50,rump___sysimpl_aio_suspend50);
5458 __strong_alias(_sys___aio_suspend50,rump___sysimpl_aio_suspend50);
5459 #endif /* RUMP_KERNEL_IS_LIBC */
5460 
5461 int rump___sysimpl_stat50(const char *, struct stat *);
5462 int
5463 rump___sysimpl_stat50(const char * path, struct stat * ub)
5464 {
5465 	register_t retval[2];
5466 	int error = 0;
5467 	int rv = -1;
5468 	struct sys___stat50_args callarg;
5469 
5470 	memset(&callarg, 0, sizeof(callarg));
5471 	SPARG(&callarg, path) = path;
5472 	SPARG(&callarg, ub) = ub;
5473 
5474 	error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), retval);
5475 	rsys_seterrno(error);
5476 	if (error == 0) {
5477 		if (sizeof(int) > sizeof(register_t))
5478 			rv = *(int *)retval;
5479 		else
5480 			rv = *retval;
5481 	}
5482 	return rv;
5483 }
5484 #ifdef RUMP_KERNEL_IS_LIBC
5485 __weak_alias(stat,rump___sysimpl_stat50);
5486 __weak_alias(__stat50,rump___sysimpl_stat50);
5487 __weak_alias(___stat50,rump___sysimpl_stat50);
5488 __strong_alias(_sys___stat50,rump___sysimpl_stat50);
5489 #endif /* RUMP_KERNEL_IS_LIBC */
5490 
5491 int rump___sysimpl_fstat50(int, struct stat *);
5492 int
5493 rump___sysimpl_fstat50(int fd, struct stat * sb)
5494 {
5495 	register_t retval[2];
5496 	int error = 0;
5497 	int rv = -1;
5498 	struct sys___fstat50_args callarg;
5499 
5500 	memset(&callarg, 0, sizeof(callarg));
5501 	SPARG(&callarg, fd) = fd;
5502 	SPARG(&callarg, sb) = sb;
5503 
5504 	error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), retval);
5505 	rsys_seterrno(error);
5506 	if (error == 0) {
5507 		if (sizeof(int) > sizeof(register_t))
5508 			rv = *(int *)retval;
5509 		else
5510 			rv = *retval;
5511 	}
5512 	return rv;
5513 }
5514 #ifdef RUMP_KERNEL_IS_LIBC
5515 __weak_alias(fstat,rump___sysimpl_fstat50);
5516 __weak_alias(__fstat50,rump___sysimpl_fstat50);
5517 __weak_alias(___fstat50,rump___sysimpl_fstat50);
5518 __strong_alias(_sys___fstat50,rump___sysimpl_fstat50);
5519 #endif /* RUMP_KERNEL_IS_LIBC */
5520 
5521 int rump___sysimpl_lstat50(const char *, struct stat *);
5522 int
5523 rump___sysimpl_lstat50(const char * path, struct stat * ub)
5524 {
5525 	register_t retval[2];
5526 	int error = 0;
5527 	int rv = -1;
5528 	struct sys___lstat50_args callarg;
5529 
5530 	memset(&callarg, 0, sizeof(callarg));
5531 	SPARG(&callarg, path) = path;
5532 	SPARG(&callarg, ub) = ub;
5533 
5534 	error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), retval);
5535 	rsys_seterrno(error);
5536 	if (error == 0) {
5537 		if (sizeof(int) > sizeof(register_t))
5538 			rv = *(int *)retval;
5539 		else
5540 			rv = *retval;
5541 	}
5542 	return rv;
5543 }
5544 #ifdef RUMP_KERNEL_IS_LIBC
5545 __weak_alias(lstat,rump___sysimpl_lstat50);
5546 __weak_alias(__lstat50,rump___sysimpl_lstat50);
5547 __weak_alias(___lstat50,rump___sysimpl_lstat50);
5548 __strong_alias(_sys___lstat50,rump___sysimpl_lstat50);
5549 #endif /* RUMP_KERNEL_IS_LIBC */
5550 
5551 int rump___sysimpl_timer_settime50(timer_t, int, const struct itimerspec *, struct itimerspec *);
5552 int
5553 rump___sysimpl_timer_settime50(timer_t timerid, int flags, const struct itimerspec * value, struct itimerspec * ovalue)
5554 {
5555 	register_t retval[2];
5556 	int error = 0;
5557 	int rv = -1;
5558 	struct sys___timer_settime50_args callarg;
5559 
5560 	memset(&callarg, 0, sizeof(callarg));
5561 	SPARG(&callarg, timerid) = timerid;
5562 	SPARG(&callarg, flags) = flags;
5563 	SPARG(&callarg, value) = value;
5564 	SPARG(&callarg, ovalue) = ovalue;
5565 
5566 	error = rsys_syscall(SYS___timer_settime50, &callarg, sizeof(callarg), retval);
5567 	rsys_seterrno(error);
5568 	if (error == 0) {
5569 		if (sizeof(int) > sizeof(register_t))
5570 			rv = *(int *)retval;
5571 		else
5572 			rv = *retval;
5573 	}
5574 	return rv;
5575 }
5576 #ifdef RUMP_KERNEL_IS_LIBC
5577 __weak_alias(timer_settime,rump___sysimpl_timer_settime50);
5578 __weak_alias(__timer_settime50,rump___sysimpl_timer_settime50);
5579 __weak_alias(___timer_settime50,rump___sysimpl_timer_settime50);
5580 __strong_alias(_sys___timer_settime50,rump___sysimpl_timer_settime50);
5581 #endif /* RUMP_KERNEL_IS_LIBC */
5582 
5583 int rump___sysimpl_timer_gettime50(timer_t, struct itimerspec *);
5584 int
5585 rump___sysimpl_timer_gettime50(timer_t timerid, struct itimerspec * value)
5586 {
5587 	register_t retval[2];
5588 	int error = 0;
5589 	int rv = -1;
5590 	struct sys___timer_gettime50_args callarg;
5591 
5592 	memset(&callarg, 0, sizeof(callarg));
5593 	SPARG(&callarg, timerid) = timerid;
5594 	SPARG(&callarg, value) = value;
5595 
5596 	error = rsys_syscall(SYS___timer_gettime50, &callarg, sizeof(callarg), retval);
5597 	rsys_seterrno(error);
5598 	if (error == 0) {
5599 		if (sizeof(int) > sizeof(register_t))
5600 			rv = *(int *)retval;
5601 		else
5602 			rv = *retval;
5603 	}
5604 	return rv;
5605 }
5606 #ifdef RUMP_KERNEL_IS_LIBC
5607 __weak_alias(timer_gettime,rump___sysimpl_timer_gettime50);
5608 __weak_alias(__timer_gettime50,rump___sysimpl_timer_gettime50);
5609 __weak_alias(___timer_gettime50,rump___sysimpl_timer_gettime50);
5610 __strong_alias(_sys___timer_gettime50,rump___sysimpl_timer_gettime50);
5611 #endif /* RUMP_KERNEL_IS_LIBC */
5612 
5613 int rump___sysimpl_mknod50(const char *, mode_t, dev_t);
5614 int
5615 rump___sysimpl_mknod50(const char * path, mode_t mode, dev_t dev)
5616 {
5617 	register_t retval[2];
5618 	int error = 0;
5619 	int rv = -1;
5620 	struct sys___mknod50_args callarg;
5621 
5622 	memset(&callarg, 0, sizeof(callarg));
5623 	SPARG(&callarg, path) = path;
5624 	SPARG(&callarg, mode) = mode;
5625 	SPARG(&callarg, dev) = dev;
5626 
5627 	error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), retval);
5628 	rsys_seterrno(error);
5629 	if (error == 0) {
5630 		if (sizeof(int) > sizeof(register_t))
5631 			rv = *(int *)retval;
5632 		else
5633 			rv = *retval;
5634 	}
5635 	return rv;
5636 }
5637 #ifdef RUMP_KERNEL_IS_LIBC
5638 __weak_alias(mknod,rump___sysimpl_mknod50);
5639 __weak_alias(__mknod50,rump___sysimpl_mknod50);
5640 __weak_alias(___mknod50,rump___sysimpl_mknod50);
5641 __strong_alias(_sys___mknod50,rump___sysimpl_mknod50);
5642 #endif /* RUMP_KERNEL_IS_LIBC */
5643 
5644 int rump___sysimpl_fhstat50(const void *, size_t, struct stat *);
5645 int
5646 rump___sysimpl_fhstat50(const void * fhp, size_t fh_size, struct stat * sb)
5647 {
5648 	register_t retval[2];
5649 	int error = 0;
5650 	int rv = -1;
5651 	struct sys___fhstat50_args callarg;
5652 
5653 	memset(&callarg, 0, sizeof(callarg));
5654 	SPARG(&callarg, fhp) = fhp;
5655 	SPARG(&callarg, fh_size) = fh_size;
5656 	SPARG(&callarg, sb) = sb;
5657 
5658 	error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), retval);
5659 	rsys_seterrno(error);
5660 	if (error == 0) {
5661 		if (sizeof(int) > sizeof(register_t))
5662 			rv = *(int *)retval;
5663 		else
5664 			rv = *retval;
5665 	}
5666 	return rv;
5667 }
5668 #ifdef RUMP_KERNEL_IS_LIBC
5669 __weak_alias(fhstat,rump___sysimpl_fhstat50);
5670 __weak_alias(__fhstat50,rump___sysimpl_fhstat50);
5671 __weak_alias(___fhstat50,rump___sysimpl_fhstat50);
5672 __strong_alias(_sys___fhstat50,rump___sysimpl_fhstat50);
5673 #endif /* RUMP_KERNEL_IS_LIBC */
5674 
5675 int rump___sysimpl_pipe2(int *, int);
5676 int
5677 rump___sysimpl_pipe2(int * fildes, int flags)
5678 {
5679 	register_t retval[2];
5680 	int error = 0;
5681 	int rv = -1;
5682 	struct sys_pipe2_args callarg;
5683 
5684 	memset(&callarg, 0, sizeof(callarg));
5685 	SPARG(&callarg, fildes) = fildes;
5686 	SPARG(&callarg, flags) = flags;
5687 
5688 	error = rsys_syscall(SYS_pipe2, &callarg, sizeof(callarg), retval);
5689 	rsys_seterrno(error);
5690 	if (error == 0) {
5691 		if (sizeof(int) > sizeof(register_t))
5692 			rv = *(int *)retval;
5693 		else
5694 			rv = *retval;
5695 	}
5696 	return rv;
5697 }
5698 #ifdef RUMP_KERNEL_IS_LIBC
5699 __weak_alias(pipe2,rump___sysimpl_pipe2);
5700 __weak_alias(_pipe2,rump___sysimpl_pipe2);
5701 __strong_alias(_sys_pipe2,rump___sysimpl_pipe2);
5702 #endif /* RUMP_KERNEL_IS_LIBC */
5703 
5704 #ifdef RUMP_SYS_COMPAT
5705 int rump___sysimpl_dup3(int, int, int);
5706 int
5707 rump___sysimpl_dup3(int from, int to, int flags)
5708 {
5709 	register_t retval[2];
5710 	int error = 0;
5711 	int rv = -1;
5712 	struct compat_100_sys_dup3_args callarg;
5713 
5714 	memset(&callarg, 0, sizeof(callarg));
5715 	SPARG(&callarg, from) = from;
5716 	SPARG(&callarg, to) = to;
5717 	SPARG(&callarg, flags) = flags;
5718 
5719 	error = rsys_syscall(SYS_compat_100_dup3, &callarg, sizeof(callarg), retval);
5720 	rsys_seterrno(error);
5721 	if (error == 0) {
5722 		if (sizeof(int) > sizeof(register_t))
5723 			rv = *(int *)retval;
5724 		else
5725 			rv = *retval;
5726 	}
5727 	return rv;
5728 }
5729 #ifdef RUMP_KERNEL_IS_LIBC
5730 __weak_alias(dup3,rump___sysimpl_dup3);
5731 __weak_alias(_dup3,rump___sysimpl_dup3);
5732 __strong_alias(_sys_dup3,rump___sysimpl_dup3);
5733 #endif /* RUMP_KERNEL_IS_LIBC */
5734 #endif /* RUMP_SYS_COMPAT */
5735 
5736 int rump___sysimpl_kqueue1(int);
5737 int
5738 rump___sysimpl_kqueue1(int flags)
5739 {
5740 	register_t retval[2];
5741 	int error = 0;
5742 	int rv = -1;
5743 	struct sys_kqueue1_args callarg;
5744 
5745 	memset(&callarg, 0, sizeof(callarg));
5746 	SPARG(&callarg, flags) = flags;
5747 
5748 	error = rsys_syscall(SYS_kqueue1, &callarg, sizeof(callarg), retval);
5749 	rsys_seterrno(error);
5750 	if (error == 0) {
5751 		if (sizeof(int) > sizeof(register_t))
5752 			rv = *(int *)retval;
5753 		else
5754 			rv = *retval;
5755 	}
5756 	return rv;
5757 }
5758 #ifdef RUMP_KERNEL_IS_LIBC
5759 __weak_alias(kqueue1,rump___sysimpl_kqueue1);
5760 __weak_alias(_kqueue1,rump___sysimpl_kqueue1);
5761 __strong_alias(_sys_kqueue1,rump___sysimpl_kqueue1);
5762 #endif /* RUMP_KERNEL_IS_LIBC */
5763 
5764 int rump___sysimpl_paccept(int, struct sockaddr *, socklen_t *, const sigset_t *, int);
5765 int
5766 rump___sysimpl_paccept(int s, struct sockaddr * name, socklen_t * anamelen, const sigset_t * mask, int flags)
5767 {
5768 	register_t retval[2];
5769 	int error = 0;
5770 	int rv = -1;
5771 	struct sys_paccept_args callarg;
5772 
5773 	memset(&callarg, 0, sizeof(callarg));
5774 	SPARG(&callarg, s) = s;
5775 	SPARG(&callarg, name) = name;
5776 	SPARG(&callarg, anamelen) = anamelen;
5777 	SPARG(&callarg, mask) = mask;
5778 	SPARG(&callarg, flags) = flags;
5779 
5780 	error = rsys_syscall(SYS_paccept, &callarg, sizeof(callarg), retval);
5781 	rsys_seterrno(error);
5782 	if (error == 0) {
5783 		if (sizeof(int) > sizeof(register_t))
5784 			rv = *(int *)retval;
5785 		else
5786 			rv = *retval;
5787 	}
5788 	return rv;
5789 }
5790 #ifdef RUMP_KERNEL_IS_LIBC
5791 __weak_alias(paccept,rump___sysimpl_paccept);
5792 __weak_alias(_paccept,rump___sysimpl_paccept);
5793 __strong_alias(_sys_paccept,rump___sysimpl_paccept);
5794 #endif /* RUMP_KERNEL_IS_LIBC */
5795 
5796 int rump___sysimpl_linkat(int, const char *, int, const char *, int);
5797 int
5798 rump___sysimpl_linkat(int fd1, const char * name1, int fd2, const char * name2, int flags)
5799 {
5800 	register_t retval[2];
5801 	int error = 0;
5802 	int rv = -1;
5803 	struct sys_linkat_args callarg;
5804 
5805 	memset(&callarg, 0, sizeof(callarg));
5806 	SPARG(&callarg, fd1) = fd1;
5807 	SPARG(&callarg, name1) = name1;
5808 	SPARG(&callarg, fd2) = fd2;
5809 	SPARG(&callarg, name2) = name2;
5810 	SPARG(&callarg, flags) = flags;
5811 
5812 	error = rsys_syscall(SYS_linkat, &callarg, sizeof(callarg), retval);
5813 	rsys_seterrno(error);
5814 	if (error == 0) {
5815 		if (sizeof(int) > sizeof(register_t))
5816 			rv = *(int *)retval;
5817 		else
5818 			rv = *retval;
5819 	}
5820 	return rv;
5821 }
5822 #ifdef RUMP_KERNEL_IS_LIBC
5823 __weak_alias(linkat,rump___sysimpl_linkat);
5824 __weak_alias(_linkat,rump___sysimpl_linkat);
5825 __strong_alias(_sys_linkat,rump___sysimpl_linkat);
5826 #endif /* RUMP_KERNEL_IS_LIBC */
5827 
5828 int rump___sysimpl_renameat(int, const char *, int, const char *);
5829 int
5830 rump___sysimpl_renameat(int fromfd, const char * from, int tofd, const char * to)
5831 {
5832 	register_t retval[2];
5833 	int error = 0;
5834 	int rv = -1;
5835 	struct sys_renameat_args callarg;
5836 
5837 	memset(&callarg, 0, sizeof(callarg));
5838 	SPARG(&callarg, fromfd) = fromfd;
5839 	SPARG(&callarg, from) = from;
5840 	SPARG(&callarg, tofd) = tofd;
5841 	SPARG(&callarg, to) = to;
5842 
5843 	error = rsys_syscall(SYS_renameat, &callarg, sizeof(callarg), retval);
5844 	rsys_seterrno(error);
5845 	if (error == 0) {
5846 		if (sizeof(int) > sizeof(register_t))
5847 			rv = *(int *)retval;
5848 		else
5849 			rv = *retval;
5850 	}
5851 	return rv;
5852 }
5853 #ifdef RUMP_KERNEL_IS_LIBC
5854 __weak_alias(renameat,rump___sysimpl_renameat);
5855 __weak_alias(_renameat,rump___sysimpl_renameat);
5856 __strong_alias(_sys_renameat,rump___sysimpl_renameat);
5857 #endif /* RUMP_KERNEL_IS_LIBC */
5858 
5859 int rump___sysimpl_mkfifoat(int, const char *, mode_t);
5860 int
5861 rump___sysimpl_mkfifoat(int fd, const char * path, mode_t mode)
5862 {
5863 	register_t retval[2];
5864 	int error = 0;
5865 	int rv = -1;
5866 	struct sys_mkfifoat_args callarg;
5867 
5868 	memset(&callarg, 0, sizeof(callarg));
5869 	SPARG(&callarg, fd) = fd;
5870 	SPARG(&callarg, path) = path;
5871 	SPARG(&callarg, mode) = mode;
5872 
5873 	error = rsys_syscall(SYS_mkfifoat, &callarg, sizeof(callarg), retval);
5874 	rsys_seterrno(error);
5875 	if (error == 0) {
5876 		if (sizeof(int) > sizeof(register_t))
5877 			rv = *(int *)retval;
5878 		else
5879 			rv = *retval;
5880 	}
5881 	return rv;
5882 }
5883 #ifdef RUMP_KERNEL_IS_LIBC
5884 __weak_alias(mkfifoat,rump___sysimpl_mkfifoat);
5885 __weak_alias(_mkfifoat,rump___sysimpl_mkfifoat);
5886 __strong_alias(_sys_mkfifoat,rump___sysimpl_mkfifoat);
5887 #endif /* RUMP_KERNEL_IS_LIBC */
5888 
5889 int rump___sysimpl_mknodat(int, const char *, mode_t, dev_t);
5890 int
5891 rump___sysimpl_mknodat(int fd, const char * path, mode_t mode, dev_t dev)
5892 {
5893 	register_t retval[2];
5894 	int error = 0;
5895 	int rv = -1;
5896 	struct sys_mknodat_args callarg;
5897 
5898 	memset(&callarg, 0, sizeof(callarg));
5899 	SPARG(&callarg, fd) = fd;
5900 	SPARG(&callarg, path) = path;
5901 	SPARG(&callarg, mode) = mode;
5902 	SPARG(&callarg, PAD) = 0;
5903 	SPARG(&callarg, dev) = dev;
5904 
5905 	error = rsys_syscall(SYS_mknodat, &callarg, sizeof(callarg), retval);
5906 	rsys_seterrno(error);
5907 	if (error == 0) {
5908 		if (sizeof(int) > sizeof(register_t))
5909 			rv = *(int *)retval;
5910 		else
5911 			rv = *retval;
5912 	}
5913 	return rv;
5914 }
5915 #ifdef RUMP_KERNEL_IS_LIBC
5916 __weak_alias(mknodat,rump___sysimpl_mknodat);
5917 __weak_alias(_mknodat,rump___sysimpl_mknodat);
5918 __strong_alias(_sys_mknodat,rump___sysimpl_mknodat);
5919 #endif /* RUMP_KERNEL_IS_LIBC */
5920 
5921 int rump___sysimpl_mkdirat(int, const char *, mode_t);
5922 int
5923 rump___sysimpl_mkdirat(int fd, const char * path, mode_t mode)
5924 {
5925 	register_t retval[2];
5926 	int error = 0;
5927 	int rv = -1;
5928 	struct sys_mkdirat_args callarg;
5929 
5930 	memset(&callarg, 0, sizeof(callarg));
5931 	SPARG(&callarg, fd) = fd;
5932 	SPARG(&callarg, path) = path;
5933 	SPARG(&callarg, mode) = mode;
5934 
5935 	error = rsys_syscall(SYS_mkdirat, &callarg, sizeof(callarg), retval);
5936 	rsys_seterrno(error);
5937 	if (error == 0) {
5938 		if (sizeof(int) > sizeof(register_t))
5939 			rv = *(int *)retval;
5940 		else
5941 			rv = *retval;
5942 	}
5943 	return rv;
5944 }
5945 #ifdef RUMP_KERNEL_IS_LIBC
5946 __weak_alias(mkdirat,rump___sysimpl_mkdirat);
5947 __weak_alias(_mkdirat,rump___sysimpl_mkdirat);
5948 __strong_alias(_sys_mkdirat,rump___sysimpl_mkdirat);
5949 #endif /* RUMP_KERNEL_IS_LIBC */
5950 
5951 int rump___sysimpl_faccessat(int, const char *, int, int);
5952 int
5953 rump___sysimpl_faccessat(int fd, const char * path, int amode, int flag)
5954 {
5955 	register_t retval[2];
5956 	int error = 0;
5957 	int rv = -1;
5958 	struct sys_faccessat_args callarg;
5959 
5960 	memset(&callarg, 0, sizeof(callarg));
5961 	SPARG(&callarg, fd) = fd;
5962 	SPARG(&callarg, path) = path;
5963 	SPARG(&callarg, amode) = amode;
5964 	SPARG(&callarg, flag) = flag;
5965 
5966 	error = rsys_syscall(SYS_faccessat, &callarg, sizeof(callarg), retval);
5967 	rsys_seterrno(error);
5968 	if (error == 0) {
5969 		if (sizeof(int) > sizeof(register_t))
5970 			rv = *(int *)retval;
5971 		else
5972 			rv = *retval;
5973 	}
5974 	return rv;
5975 }
5976 #ifdef RUMP_KERNEL_IS_LIBC
5977 __weak_alias(faccessat,rump___sysimpl_faccessat);
5978 __weak_alias(_faccessat,rump___sysimpl_faccessat);
5979 __strong_alias(_sys_faccessat,rump___sysimpl_faccessat);
5980 #endif /* RUMP_KERNEL_IS_LIBC */
5981 
5982 int rump___sysimpl_fchmodat(int, const char *, mode_t, int);
5983 int
5984 rump___sysimpl_fchmodat(int fd, const char * path, mode_t mode, int flag)
5985 {
5986 	register_t retval[2];
5987 	int error = 0;
5988 	int rv = -1;
5989 	struct sys_fchmodat_args callarg;
5990 
5991 	memset(&callarg, 0, sizeof(callarg));
5992 	SPARG(&callarg, fd) = fd;
5993 	SPARG(&callarg, path) = path;
5994 	SPARG(&callarg, mode) = mode;
5995 	SPARG(&callarg, flag) = flag;
5996 
5997 	error = rsys_syscall(SYS_fchmodat, &callarg, sizeof(callarg), retval);
5998 	rsys_seterrno(error);
5999 	if (error == 0) {
6000 		if (sizeof(int) > sizeof(register_t))
6001 			rv = *(int *)retval;
6002 		else
6003 			rv = *retval;
6004 	}
6005 	return rv;
6006 }
6007 #ifdef RUMP_KERNEL_IS_LIBC
6008 __weak_alias(fchmodat,rump___sysimpl_fchmodat);
6009 __weak_alias(_fchmodat,rump___sysimpl_fchmodat);
6010 __strong_alias(_sys_fchmodat,rump___sysimpl_fchmodat);
6011 #endif /* RUMP_KERNEL_IS_LIBC */
6012 
6013 int rump___sysimpl_fchownat(int, const char *, uid_t, gid_t, int);
6014 int
6015 rump___sysimpl_fchownat(int fd, const char * path, uid_t owner, gid_t group, int flag)
6016 {
6017 	register_t retval[2];
6018 	int error = 0;
6019 	int rv = -1;
6020 	struct sys_fchownat_args callarg;
6021 
6022 	memset(&callarg, 0, sizeof(callarg));
6023 	SPARG(&callarg, fd) = fd;
6024 	SPARG(&callarg, path) = path;
6025 	SPARG(&callarg, owner) = owner;
6026 	SPARG(&callarg, group) = group;
6027 	SPARG(&callarg, flag) = flag;
6028 
6029 	error = rsys_syscall(SYS_fchownat, &callarg, sizeof(callarg), retval);
6030 	rsys_seterrno(error);
6031 	if (error == 0) {
6032 		if (sizeof(int) > sizeof(register_t))
6033 			rv = *(int *)retval;
6034 		else
6035 			rv = *retval;
6036 	}
6037 	return rv;
6038 }
6039 #ifdef RUMP_KERNEL_IS_LIBC
6040 __weak_alias(fchownat,rump___sysimpl_fchownat);
6041 __weak_alias(_fchownat,rump___sysimpl_fchownat);
6042 __strong_alias(_sys_fchownat,rump___sysimpl_fchownat);
6043 #endif /* RUMP_KERNEL_IS_LIBC */
6044 
6045 int rump___sysimpl_fstatat(int, const char *, struct stat *, int);
6046 int
6047 rump___sysimpl_fstatat(int fd, const char * path, struct stat * buf, int flag)
6048 {
6049 	register_t retval[2];
6050 	int error = 0;
6051 	int rv = -1;
6052 	struct sys_fstatat_args callarg;
6053 
6054 	memset(&callarg, 0, sizeof(callarg));
6055 	SPARG(&callarg, fd) = fd;
6056 	SPARG(&callarg, path) = path;
6057 	SPARG(&callarg, buf) = buf;
6058 	SPARG(&callarg, flag) = flag;
6059 
6060 	error = rsys_syscall(SYS_fstatat, &callarg, sizeof(callarg), retval);
6061 	rsys_seterrno(error);
6062 	if (error == 0) {
6063 		if (sizeof(int) > sizeof(register_t))
6064 			rv = *(int *)retval;
6065 		else
6066 			rv = *retval;
6067 	}
6068 	return rv;
6069 }
6070 #ifdef RUMP_KERNEL_IS_LIBC
6071 __weak_alias(fstatat,rump___sysimpl_fstatat);
6072 __weak_alias(_fstatat,rump___sysimpl_fstatat);
6073 __strong_alias(_sys_fstatat,rump___sysimpl_fstatat);
6074 #endif /* RUMP_KERNEL_IS_LIBC */
6075 
6076 int rump___sysimpl_utimensat(int, const char *, const struct timespec *, int);
6077 int
6078 rump___sysimpl_utimensat(int fd, const char * path, const struct timespec * tptr, int flag)
6079 {
6080 	register_t retval[2];
6081 	int error = 0;
6082 	int rv = -1;
6083 	struct sys_utimensat_args callarg;
6084 
6085 	memset(&callarg, 0, sizeof(callarg));
6086 	SPARG(&callarg, fd) = fd;
6087 	SPARG(&callarg, path) = path;
6088 	SPARG(&callarg, tptr) = tptr;
6089 	SPARG(&callarg, flag) = flag;
6090 
6091 	error = rsys_syscall(SYS_utimensat, &callarg, sizeof(callarg), retval);
6092 	rsys_seterrno(error);
6093 	if (error == 0) {
6094 		if (sizeof(int) > sizeof(register_t))
6095 			rv = *(int *)retval;
6096 		else
6097 			rv = *retval;
6098 	}
6099 	return rv;
6100 }
6101 #ifdef RUMP_KERNEL_IS_LIBC
6102 __weak_alias(utimensat,rump___sysimpl_utimensat);
6103 __weak_alias(_utimensat,rump___sysimpl_utimensat);
6104 __strong_alias(_sys_utimensat,rump___sysimpl_utimensat);
6105 #endif /* RUMP_KERNEL_IS_LIBC */
6106 
6107 int rump___sysimpl_openat(int, const char *, int, mode_t);
6108 int
6109 rump___sysimpl_openat(int fd, const char * path, int oflags, mode_t mode)
6110 {
6111 	register_t retval[2];
6112 	int error = 0;
6113 	int rv = -1;
6114 	struct sys_openat_args callarg;
6115 
6116 	memset(&callarg, 0, sizeof(callarg));
6117 	SPARG(&callarg, fd) = fd;
6118 	SPARG(&callarg, path) = path;
6119 	SPARG(&callarg, oflags) = oflags;
6120 	SPARG(&callarg, mode) = mode;
6121 
6122 	error = rsys_syscall(SYS_openat, &callarg, sizeof(callarg), retval);
6123 	rsys_seterrno(error);
6124 	if (error == 0) {
6125 		if (sizeof(int) > sizeof(register_t))
6126 			rv = *(int *)retval;
6127 		else
6128 			rv = *retval;
6129 	}
6130 	return rv;
6131 }
6132 #ifdef RUMP_KERNEL_IS_LIBC
6133 __weak_alias(openat,rump___sysimpl_openat);
6134 __weak_alias(_openat,rump___sysimpl_openat);
6135 __strong_alias(_sys_openat,rump___sysimpl_openat);
6136 #endif /* RUMP_KERNEL_IS_LIBC */
6137 
6138 ssize_t rump___sysimpl_readlinkat(int, const char *, char *, size_t);
6139 ssize_t
6140 rump___sysimpl_readlinkat(int fd, const char * path, char * buf, size_t bufsize)
6141 {
6142 	register_t retval[2];
6143 	int error = 0;
6144 	ssize_t rv = -1;
6145 	struct sys_readlinkat_args callarg;
6146 
6147 	memset(&callarg, 0, sizeof(callarg));
6148 	SPARG(&callarg, fd) = fd;
6149 	SPARG(&callarg, path) = path;
6150 	SPARG(&callarg, buf) = buf;
6151 	SPARG(&callarg, bufsize) = bufsize;
6152 
6153 	error = rsys_syscall(SYS_readlinkat, &callarg, sizeof(callarg), retval);
6154 	rsys_seterrno(error);
6155 	if (error == 0) {
6156 		if (sizeof(ssize_t) > sizeof(register_t))
6157 			rv = *(ssize_t *)retval;
6158 		else
6159 			rv = *retval;
6160 	}
6161 	return rv;
6162 }
6163 #ifdef RUMP_KERNEL_IS_LIBC
6164 __weak_alias(readlinkat,rump___sysimpl_readlinkat);
6165 __weak_alias(_readlinkat,rump___sysimpl_readlinkat);
6166 __strong_alias(_sys_readlinkat,rump___sysimpl_readlinkat);
6167 #endif /* RUMP_KERNEL_IS_LIBC */
6168 
6169 int rump___sysimpl_symlinkat(const char *, int, const char *);
6170 int
6171 rump___sysimpl_symlinkat(const char * path1, int fd, const char * path2)
6172 {
6173 	register_t retval[2];
6174 	int error = 0;
6175 	int rv = -1;
6176 	struct sys_symlinkat_args callarg;
6177 
6178 	memset(&callarg, 0, sizeof(callarg));
6179 	SPARG(&callarg, path1) = path1;
6180 	SPARG(&callarg, fd) = fd;
6181 	SPARG(&callarg, path2) = path2;
6182 
6183 	error = rsys_syscall(SYS_symlinkat, &callarg, sizeof(callarg), retval);
6184 	rsys_seterrno(error);
6185 	if (error == 0) {
6186 		if (sizeof(int) > sizeof(register_t))
6187 			rv = *(int *)retval;
6188 		else
6189 			rv = *retval;
6190 	}
6191 	return rv;
6192 }
6193 #ifdef RUMP_KERNEL_IS_LIBC
6194 __weak_alias(symlinkat,rump___sysimpl_symlinkat);
6195 __weak_alias(_symlinkat,rump___sysimpl_symlinkat);
6196 __strong_alias(_sys_symlinkat,rump___sysimpl_symlinkat);
6197 #endif /* RUMP_KERNEL_IS_LIBC */
6198 
6199 int rump___sysimpl_unlinkat(int, const char *, int);
6200 int
6201 rump___sysimpl_unlinkat(int fd, const char * path, int flag)
6202 {
6203 	register_t retval[2];
6204 	int error = 0;
6205 	int rv = -1;
6206 	struct sys_unlinkat_args callarg;
6207 
6208 	memset(&callarg, 0, sizeof(callarg));
6209 	SPARG(&callarg, fd) = fd;
6210 	SPARG(&callarg, path) = path;
6211 	SPARG(&callarg, flag) = flag;
6212 
6213 	error = rsys_syscall(SYS_unlinkat, &callarg, sizeof(callarg), retval);
6214 	rsys_seterrno(error);
6215 	if (error == 0) {
6216 		if (sizeof(int) > sizeof(register_t))
6217 			rv = *(int *)retval;
6218 		else
6219 			rv = *retval;
6220 	}
6221 	return rv;
6222 }
6223 #ifdef RUMP_KERNEL_IS_LIBC
6224 __weak_alias(unlinkat,rump___sysimpl_unlinkat);
6225 __weak_alias(_unlinkat,rump___sysimpl_unlinkat);
6226 __strong_alias(_sys_unlinkat,rump___sysimpl_unlinkat);
6227 #endif /* RUMP_KERNEL_IS_LIBC */
6228 
6229 int rump___sysimpl_futimens(int, const struct timespec *);
6230 int
6231 rump___sysimpl_futimens(int fd, const struct timespec * tptr)
6232 {
6233 	register_t retval[2];
6234 	int error = 0;
6235 	int rv = -1;
6236 	struct sys_futimens_args callarg;
6237 
6238 	memset(&callarg, 0, sizeof(callarg));
6239 	SPARG(&callarg, fd) = fd;
6240 	SPARG(&callarg, tptr) = tptr;
6241 
6242 	error = rsys_syscall(SYS_futimens, &callarg, sizeof(callarg), retval);
6243 	rsys_seterrno(error);
6244 	if (error == 0) {
6245 		if (sizeof(int) > sizeof(register_t))
6246 			rv = *(int *)retval;
6247 		else
6248 			rv = *retval;
6249 	}
6250 	return rv;
6251 }
6252 #ifdef RUMP_KERNEL_IS_LIBC
6253 __weak_alias(futimens,rump___sysimpl_futimens);
6254 __weak_alias(_futimens,rump___sysimpl_futimens);
6255 __strong_alias(_sys_futimens,rump___sysimpl_futimens);
6256 #endif /* RUMP_KERNEL_IS_LIBC */
6257 
6258 int rump___sysimpl___quotactl(const char *, struct quotactl_args *);
6259 int
6260 rump___sysimpl___quotactl(const char * path, struct quotactl_args * args)
6261 {
6262 	register_t retval[2];
6263 	int error = 0;
6264 	int rv = -1;
6265 	struct sys___quotactl_args callarg;
6266 
6267 	memset(&callarg, 0, sizeof(callarg));
6268 	SPARG(&callarg, path) = path;
6269 	SPARG(&callarg, args) = args;
6270 
6271 	error = rsys_syscall(SYS___quotactl, &callarg, sizeof(callarg), retval);
6272 	rsys_seterrno(error);
6273 	if (error == 0) {
6274 		if (sizeof(int) > sizeof(register_t))
6275 			rv = *(int *)retval;
6276 		else
6277 			rv = *retval;
6278 	}
6279 	return rv;
6280 }
6281 #ifdef RUMP_KERNEL_IS_LIBC
6282 __weak_alias(__quotactl,rump___sysimpl___quotactl);
6283 __weak_alias(___quotactl,rump___sysimpl___quotactl);
6284 __strong_alias(_sys___quotactl,rump___sysimpl___quotactl);
6285 #endif /* RUMP_KERNEL_IS_LIBC */
6286 
6287 int rump___sysimpl_recvmmsg(int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *);
6288 int
6289 rump___sysimpl_recvmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout)
6290 {
6291 	register_t retval[2];
6292 	int error = 0;
6293 	int rv = -1;
6294 	struct sys_recvmmsg_args callarg;
6295 
6296 	memset(&callarg, 0, sizeof(callarg));
6297 	SPARG(&callarg, s) = s;
6298 	SPARG(&callarg, mmsg) = mmsg;
6299 	SPARG(&callarg, vlen) = vlen;
6300 	SPARG(&callarg, flags) = flags;
6301 	SPARG(&callarg, timeout) = timeout;
6302 
6303 	error = rsys_syscall(SYS_recvmmsg, &callarg, sizeof(callarg), retval);
6304 	rsys_seterrno(error);
6305 	if (error == 0) {
6306 		if (sizeof(int) > sizeof(register_t))
6307 			rv = *(int *)retval;
6308 		else
6309 			rv = *retval;
6310 	}
6311 	return rv;
6312 }
6313 #ifdef RUMP_KERNEL_IS_LIBC
6314 __weak_alias(recvmmsg,rump___sysimpl_recvmmsg);
6315 __weak_alias(_recvmmsg,rump___sysimpl_recvmmsg);
6316 __strong_alias(_sys_recvmmsg,rump___sysimpl_recvmmsg);
6317 #endif /* RUMP_KERNEL_IS_LIBC */
6318 
6319 int rump___sysimpl_sendmmsg(int, struct mmsghdr *, unsigned int, unsigned int);
6320 int
6321 rump___sysimpl_sendmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags)
6322 {
6323 	register_t retval[2];
6324 	int error = 0;
6325 	int rv = -1;
6326 	struct sys_sendmmsg_args callarg;
6327 
6328 	memset(&callarg, 0, sizeof(callarg));
6329 	SPARG(&callarg, s) = s;
6330 	SPARG(&callarg, mmsg) = mmsg;
6331 	SPARG(&callarg, vlen) = vlen;
6332 	SPARG(&callarg, flags) = flags;
6333 
6334 	error = rsys_syscall(SYS_sendmmsg, &callarg, sizeof(callarg), retval);
6335 	rsys_seterrno(error);
6336 	if (error == 0) {
6337 		if (sizeof(int) > sizeof(register_t))
6338 			rv = *(int *)retval;
6339 		else
6340 			rv = *retval;
6341 	}
6342 	return rv;
6343 }
6344 #ifdef RUMP_KERNEL_IS_LIBC
6345 __weak_alias(sendmmsg,rump___sysimpl_sendmmsg);
6346 __weak_alias(_sendmmsg,rump___sysimpl_sendmmsg);
6347 __strong_alias(_sys_sendmmsg,rump___sysimpl_sendmmsg);
6348 #endif /* RUMP_KERNEL_IS_LIBC */
6349 
6350 int rump___sysimpl_clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *);
6351 int
6352 rump___sysimpl_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp)
6353 {
6354 	register_t retval[2];
6355 	int rv = -1;
6356 	struct sys_clock_nanosleep_args callarg;
6357 
6358 	memset(&callarg, 0, sizeof(callarg));
6359 	SPARG(&callarg, clock_id) = clock_id;
6360 	SPARG(&callarg, flags) = flags;
6361 	SPARG(&callarg, rqtp) = rqtp;
6362 	SPARG(&callarg, rmtp) = rmtp;
6363 
6364 	(void)rsys_syscall(SYS_clock_nanosleep, &callarg, sizeof(callarg), retval);
6365 	if (sizeof(int) > sizeof(register_t))
6366 		rv = *(int *)retval;
6367 	else
6368 		rv = *retval;
6369 	return rv;
6370 }
6371 #ifdef RUMP_KERNEL_IS_LIBC
6372 __weak_alias(clock_nanosleep,rump___sysimpl_clock_nanosleep);
6373 __weak_alias(_clock_nanosleep,rump___sysimpl_clock_nanosleep);
6374 __strong_alias(_sys_clock_nanosleep,rump___sysimpl_clock_nanosleep);
6375 #endif /* RUMP_KERNEL_IS_LIBC */
6376 
6377 int rump___sysimpl_posix_fallocate(int, off_t, off_t);
6378 int
6379 rump___sysimpl_posix_fallocate(int fd, off_t pos, off_t len)
6380 {
6381 	register_t retval[2];
6382 	int rv = -1;
6383 	struct sys_posix_fallocate_args callarg;
6384 
6385 	memset(&callarg, 0, sizeof(callarg));
6386 	SPARG(&callarg, fd) = fd;
6387 	SPARG(&callarg, PAD) = 0;
6388 	SPARG(&callarg, pos) = pos;
6389 	SPARG(&callarg, len) = len;
6390 
6391 	(void)rsys_syscall(SYS_posix_fallocate, &callarg, sizeof(callarg), retval);
6392 	if (sizeof(int) > sizeof(register_t))
6393 		rv = *(int *)retval;
6394 	else
6395 		rv = *retval;
6396 	return rv;
6397 }
6398 #ifdef RUMP_KERNEL_IS_LIBC
6399 __weak_alias(posix_fallocate,rump___sysimpl_posix_fallocate);
6400 __weak_alias(_posix_fallocate,rump___sysimpl_posix_fallocate);
6401 __strong_alias(_sys_posix_fallocate,rump___sysimpl_posix_fallocate);
6402 #endif /* RUMP_KERNEL_IS_LIBC */
6403 
6404 int rump___sysimpl_fdiscard(int, off_t, off_t);
6405 int
6406 rump___sysimpl_fdiscard(int fd, off_t pos, off_t len)
6407 {
6408 	register_t retval[2];
6409 	int error = 0;
6410 	int rv = -1;
6411 	struct sys_fdiscard_args callarg;
6412 
6413 	memset(&callarg, 0, sizeof(callarg));
6414 	SPARG(&callarg, fd) = fd;
6415 	SPARG(&callarg, PAD) = 0;
6416 	SPARG(&callarg, pos) = pos;
6417 	SPARG(&callarg, len) = len;
6418 
6419 	error = rsys_syscall(SYS_fdiscard, &callarg, sizeof(callarg), retval);
6420 	rsys_seterrno(error);
6421 	if (error == 0) {
6422 		if (sizeof(int) > sizeof(register_t))
6423 			rv = *(int *)retval;
6424 		else
6425 			rv = *retval;
6426 	}
6427 	return rv;
6428 }
6429 #ifdef RUMP_KERNEL_IS_LIBC
6430 __weak_alias(fdiscard,rump___sysimpl_fdiscard);
6431 __weak_alias(_fdiscard,rump___sysimpl_fdiscard);
6432 __strong_alias(_sys_fdiscard,rump___sysimpl_fdiscard);
6433 #endif /* RUMP_KERNEL_IS_LIBC */
6434 
6435 int rump___sysimpl_clock_getcpuclockid2(idtype_t, id_t, clockid_t *);
6436 int
6437 rump___sysimpl_clock_getcpuclockid2(idtype_t idtype, id_t id, clockid_t * clock_id)
6438 {
6439 	register_t retval[2];
6440 	int error = 0;
6441 	int rv = -1;
6442 	struct sys_clock_getcpuclockid2_args callarg;
6443 
6444 	memset(&callarg, 0, sizeof(callarg));
6445 	SPARG(&callarg, idtype) = idtype;
6446 	SPARG(&callarg, id) = id;
6447 	SPARG(&callarg, clock_id) = clock_id;
6448 
6449 	error = rsys_syscall(SYS_clock_getcpuclockid2, &callarg, sizeof(callarg), retval);
6450 	rsys_seterrno(error);
6451 	if (error == 0) {
6452 		if (sizeof(int) > sizeof(register_t))
6453 			rv = *(int *)retval;
6454 		else
6455 			rv = *retval;
6456 	}
6457 	return rv;
6458 }
6459 #ifdef RUMP_KERNEL_IS_LIBC
6460 __weak_alias(clock_getcpuclockid2,rump___sysimpl_clock_getcpuclockid2);
6461 __weak_alias(_clock_getcpuclockid2,rump___sysimpl_clock_getcpuclockid2);
6462 __strong_alias(_sys_clock_getcpuclockid2,rump___sysimpl_clock_getcpuclockid2);
6463 #endif /* RUMP_KERNEL_IS_LIBC */
6464 
6465 int rump___sysimpl_getvfsstat90(struct statvfs *, size_t, int);
6466 int
6467 rump___sysimpl_getvfsstat90(struct statvfs * buf, size_t bufsize, int flags)
6468 {
6469 	register_t retval[2];
6470 	int error = 0;
6471 	int rv = -1;
6472 	struct sys___getvfsstat90_args callarg;
6473 
6474 	memset(&callarg, 0, sizeof(callarg));
6475 	SPARG(&callarg, buf) = buf;
6476 	SPARG(&callarg, bufsize) = bufsize;
6477 	SPARG(&callarg, flags) = flags;
6478 
6479 	error = rsys_syscall(SYS___getvfsstat90, &callarg, sizeof(callarg), retval);
6480 	rsys_seterrno(error);
6481 	if (error == 0) {
6482 		if (sizeof(int) > sizeof(register_t))
6483 			rv = *(int *)retval;
6484 		else
6485 			rv = *retval;
6486 	}
6487 	return rv;
6488 }
6489 #ifdef RUMP_KERNEL_IS_LIBC
6490 __weak_alias(getvfsstat,rump___sysimpl_getvfsstat90);
6491 __weak_alias(__getvfsstat90,rump___sysimpl_getvfsstat90);
6492 __weak_alias(___getvfsstat90,rump___sysimpl_getvfsstat90);
6493 __strong_alias(_sys___getvfsstat90,rump___sysimpl_getvfsstat90);
6494 #endif /* RUMP_KERNEL_IS_LIBC */
6495 
6496 int rump___sysimpl_statvfs190(const char *, struct statvfs *, int);
6497 int
6498 rump___sysimpl_statvfs190(const char * path, struct statvfs * buf, int flags)
6499 {
6500 	register_t retval[2];
6501 	int error = 0;
6502 	int rv = -1;
6503 	struct sys___statvfs190_args callarg;
6504 
6505 	memset(&callarg, 0, sizeof(callarg));
6506 	SPARG(&callarg, path) = path;
6507 	SPARG(&callarg, buf) = buf;
6508 	SPARG(&callarg, flags) = flags;
6509 
6510 	error = rsys_syscall(SYS___statvfs190, &callarg, sizeof(callarg), retval);
6511 	rsys_seterrno(error);
6512 	if (error == 0) {
6513 		if (sizeof(int) > sizeof(register_t))
6514 			rv = *(int *)retval;
6515 		else
6516 			rv = *retval;
6517 	}
6518 	return rv;
6519 }
6520 #ifdef RUMP_KERNEL_IS_LIBC
6521 __weak_alias(statvfs1,rump___sysimpl_statvfs190);
6522 __weak_alias(__statvfs190,rump___sysimpl_statvfs190);
6523 __weak_alias(___statvfs190,rump___sysimpl_statvfs190);
6524 __strong_alias(_sys___statvfs190,rump___sysimpl_statvfs190);
6525 #endif /* RUMP_KERNEL_IS_LIBC */
6526 
6527 int rump___sysimpl_fstatvfs190(int, struct statvfs *, int);
6528 int
6529 rump___sysimpl_fstatvfs190(int fd, struct statvfs * buf, int flags)
6530 {
6531 	register_t retval[2];
6532 	int error = 0;
6533 	int rv = -1;
6534 	struct sys___fstatvfs190_args callarg;
6535 
6536 	memset(&callarg, 0, sizeof(callarg));
6537 	SPARG(&callarg, fd) = fd;
6538 	SPARG(&callarg, buf) = buf;
6539 	SPARG(&callarg, flags) = flags;
6540 
6541 	error = rsys_syscall(SYS___fstatvfs190, &callarg, sizeof(callarg), retval);
6542 	rsys_seterrno(error);
6543 	if (error == 0) {
6544 		if (sizeof(int) > sizeof(register_t))
6545 			rv = *(int *)retval;
6546 		else
6547 			rv = *retval;
6548 	}
6549 	return rv;
6550 }
6551 #ifdef RUMP_KERNEL_IS_LIBC
6552 __weak_alias(fstatvfs1,rump___sysimpl_fstatvfs190);
6553 __weak_alias(__fstatvfs190,rump___sysimpl_fstatvfs190);
6554 __weak_alias(___fstatvfs190,rump___sysimpl_fstatvfs190);
6555 __strong_alias(_sys___fstatvfs190,rump___sysimpl_fstatvfs190);
6556 #endif /* RUMP_KERNEL_IS_LIBC */
6557 
6558 int rump___sysimpl_fhstatvfs190(const void *, size_t, struct statvfs *, int);
6559 int
6560 rump___sysimpl_fhstatvfs190(const void * fhp, size_t fh_size, struct statvfs * buf, int flags)
6561 {
6562 	register_t retval[2];
6563 	int error = 0;
6564 	int rv = -1;
6565 	struct sys___fhstatvfs190_args callarg;
6566 
6567 	memset(&callarg, 0, sizeof(callarg));
6568 	SPARG(&callarg, fhp) = fhp;
6569 	SPARG(&callarg, fh_size) = fh_size;
6570 	SPARG(&callarg, buf) = buf;
6571 	SPARG(&callarg, flags) = flags;
6572 
6573 	error = rsys_syscall(SYS___fhstatvfs190, &callarg, sizeof(callarg), retval);
6574 	rsys_seterrno(error);
6575 	if (error == 0) {
6576 		if (sizeof(int) > sizeof(register_t))
6577 			rv = *(int *)retval;
6578 		else
6579 			rv = *retval;
6580 	}
6581 	return rv;
6582 }
6583 #ifdef RUMP_KERNEL_IS_LIBC
6584 __weak_alias(fhstatvfs1,rump___sysimpl_fhstatvfs190);
6585 __weak_alias(__fhstatvfs190,rump___sysimpl_fhstatvfs190);
6586 __weak_alias(___fhstatvfs190,rump___sysimpl_fhstatvfs190);
6587 __strong_alias(_sys___fhstatvfs190,rump___sysimpl_fhstatvfs190);
6588 #endif /* RUMP_KERNEL_IS_LIBC */
6589 
6590 long rump___sysimpl_lpathconf(const char *, int);
6591 long
6592 rump___sysimpl_lpathconf(const char * path, int name)
6593 {
6594 	register_t retval[2];
6595 	int error = 0;
6596 	long rv = -1;
6597 	struct sys_lpathconf_args callarg;
6598 
6599 	memset(&callarg, 0, sizeof(callarg));
6600 	SPARG(&callarg, path) = path;
6601 	SPARG(&callarg, name) = name;
6602 
6603 	error = rsys_syscall(SYS_lpathconf, &callarg, sizeof(callarg), retval);
6604 	rsys_seterrno(error);
6605 	if (error == 0) {
6606 		if (sizeof(long) > sizeof(register_t))
6607 			rv = *(long *)retval;
6608 		else
6609 			rv = *retval;
6610 	}
6611 	return rv;
6612 }
6613 #ifdef RUMP_KERNEL_IS_LIBC
6614 __weak_alias(lpathconf,rump___sysimpl_lpathconf);
6615 __weak_alias(_lpathconf,rump___sysimpl_lpathconf);
6616 __strong_alias(_sys_lpathconf,rump___sysimpl_lpathconf);
6617 #endif /* RUMP_KERNEL_IS_LIBC */
6618 
6619 int rump___sysimpl_kevent100(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *);
6620 int
6621 rump___sysimpl_kevent100(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout)
6622 {
6623 	register_t retval[2];
6624 	int error = 0;
6625 	int rv = -1;
6626 	struct sys___kevent100_args callarg;
6627 
6628 	memset(&callarg, 0, sizeof(callarg));
6629 	SPARG(&callarg, fd) = fd;
6630 	SPARG(&callarg, changelist) = changelist;
6631 	SPARG(&callarg, nchanges) = nchanges;
6632 	SPARG(&callarg, eventlist) = eventlist;
6633 	SPARG(&callarg, nevents) = nevents;
6634 	SPARG(&callarg, timeout) = timeout;
6635 
6636 	error = rsys_syscall(SYS___kevent100, &callarg, sizeof(callarg), retval);
6637 	rsys_seterrno(error);
6638 	if (error == 0) {
6639 		if (sizeof(int) > sizeof(register_t))
6640 			rv = *(int *)retval;
6641 		else
6642 			rv = *retval;
6643 	}
6644 	return rv;
6645 }
6646 #ifdef RUMP_KERNEL_IS_LIBC
6647 __weak_alias(kevent,rump___sysimpl_kevent100);
6648 __weak_alias(__kevent100,rump___sysimpl_kevent100);
6649 __weak_alias(___kevent100,rump___sysimpl_kevent100);
6650 __strong_alias(_sys___kevent100,rump___sysimpl_kevent100);
6651 #endif /* RUMP_KERNEL_IS_LIBC */
6652 
6653 int rump___sysimpl_dup3100(int, int, int);
6654 int
6655 rump___sysimpl_dup3100(int from, int to, int flags)
6656 {
6657 	register_t retval[2];
6658 	int error = 0;
6659 	int rv = -1;
6660 	struct sys___dup3100_args callarg;
6661 
6662 	memset(&callarg, 0, sizeof(callarg));
6663 	SPARG(&callarg, from) = from;
6664 	SPARG(&callarg, to) = to;
6665 	SPARG(&callarg, flags) = flags;
6666 
6667 	error = rsys_syscall(SYS___dup3100, &callarg, sizeof(callarg), retval);
6668 	rsys_seterrno(error);
6669 	if (error == 0) {
6670 		if (sizeof(int) > sizeof(register_t))
6671 			rv = *(int *)retval;
6672 		else
6673 			rv = *retval;
6674 	}
6675 	return rv;
6676 }
6677 #ifdef RUMP_KERNEL_IS_LIBC
6678 __weak_alias(dup3,rump___sysimpl_dup3100);
6679 __weak_alias(__dup3100,rump___sysimpl_dup3100);
6680 __weak_alias(___dup3100,rump___sysimpl_dup3100);
6681 __strong_alias(_sys___dup3100,rump___sysimpl_dup3100);
6682 #endif /* RUMP_KERNEL_IS_LIBC */
6683 
6684 int rump_sys_pipe(int *);
6685 int
6686 rump_sys_pipe(int *fd)
6687 {
6688 	register_t retval[2];
6689 	int error = 0;
6690 
6691 	error = rsys_syscall(SYS_pipe, NULL, 0, retval);
6692 	if (error) {
6693 		rsys_seterrno(error);
6694 	} else {
6695 		fd[0] = retval[0];
6696 		fd[1] = retval[1];
6697 	}
6698 	return error ? -1 : 0;
6699 }
6700 #ifdef RUMP_KERNEL_IS_LIBC
6701 __weak_alias(pipe,rump_sys_pipe);
6702 __weak_alias(_pipe,rump_sys_pipe);
6703 __strong_alias(_sys_pipe,rump_sys_pipe);
6704 #endif
6705 
6706 #ifndef RUMP_CLIENT
6707 int rumpns_enosys(void);
6708 #define	s(type)	sizeof(type)
6709 #define	n(type)	(sizeof(type)/sizeof (register_t))
6710 #define	ns(type)	n(type), s(type)
6711 
6712 struct sysent rump_sysent[] = {
6713 	{
6714 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6715 },		/* 0 = syscall */
6716 	{
6717 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6718 },		/* 1 = exit */
6719 	{
6720 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6721 },		/* 2 = fork */
6722 	{
6723 		ns(struct sys_read_args),
6724 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6725 	},		/* 3 = read */
6726 	{
6727 		ns(struct sys_write_args),
6728 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6729 	},		/* 4 = write */
6730 	{
6731 		ns(struct sys_open_args),
6732 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6733 	},		/* 5 = open */
6734 	{
6735 		ns(struct sys_close_args),
6736 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6737 	},		/* 6 = close */
6738 	{
6739 		.sy_flags = SYCALL_NOSYS,
6740 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6741 },		/* 7 = wait4 */
6742 	{
6743 		.sy_flags = SYCALL_NOSYS,
6744 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6745 },		/* 8 = ocreat */
6746 	{
6747 		ns(struct sys_link_args),
6748 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6749 	},		/* 9 = link */
6750 	{
6751 		ns(struct sys_unlink_args),
6752 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6753 	},		/* 10 = unlink */
6754 	{
6755 		.sy_flags = SYCALL_NOSYS,
6756 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6757 	},		/* 11 = filler */
6758 	{
6759 		ns(struct sys_chdir_args),
6760 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6761 	},		/* 12 = chdir */
6762 	{
6763 		ns(struct sys_fchdir_args),
6764 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6765 	},		/* 13 = fchdir */
6766 	{
6767 		ns(struct compat_50_sys_mknod_args),
6768 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6769 	},		/* 14 = compat_50_mknod */
6770 	{
6771 		ns(struct sys_chmod_args),
6772 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6773 	},		/* 15 = chmod */
6774 	{
6775 		ns(struct sys_chown_args),
6776 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6777 	},		/* 16 = chown */
6778 	{
6779 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6780 },		/* 17 = break */
6781 	{
6782 		.sy_flags = SYCALL_NOSYS,
6783 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6784 },		/* 18 = getfsstat */
6785 	{
6786 		.sy_flags = SYCALL_NOSYS,
6787 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6788 },		/* 19 = olseek */
6789 	{
6790 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6791 	},		/* 20 = getpid */
6792 	{
6793 		.sy_flags = SYCALL_NOSYS,
6794 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6795 },		/* 21 = mount */
6796 	{
6797 		ns(struct sys_unmount_args),
6798 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6799 	},		/* 22 = unmount */
6800 	{
6801 		ns(struct sys_setuid_args),
6802 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6803 	},		/* 23 = setuid */
6804 	{
6805 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6806 	},		/* 24 = getuid */
6807 	{
6808 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6809 	},		/* 25 = geteuid */
6810 	{
6811 		.sy_flags = SYCALL_NOSYS,
6812 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6813 },		/* 26 = ptrace */
6814 	{
6815 		ns(struct sys_recvmsg_args),
6816 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6817 	},		/* 27 = recvmsg */
6818 	{
6819 		ns(struct sys_sendmsg_args),
6820 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6821 	},		/* 28 = sendmsg */
6822 	{
6823 		ns(struct sys_recvfrom_args),
6824 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6825 	},		/* 29 = recvfrom */
6826 	{
6827 		ns(struct sys_accept_args),
6828 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6829 	},		/* 30 = accept */
6830 	{
6831 		ns(struct sys_getpeername_args),
6832 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6833 	},		/* 31 = getpeername */
6834 	{
6835 		ns(struct sys_getsockname_args),
6836 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6837 	},		/* 32 = getsockname */
6838 	{
6839 		ns(struct sys_access_args),
6840 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6841 	},		/* 33 = access */
6842 	{
6843 		ns(struct sys_chflags_args),
6844 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6845 	},		/* 34 = chflags */
6846 	{
6847 		ns(struct sys_fchflags_args),
6848 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6849 	},		/* 35 = fchflags */
6850 	{
6851 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6852 	},		/* 36 = sync */
6853 	{
6854 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6855 },		/* 37 = kill */
6856 	{
6857 		.sy_flags = SYCALL_NOSYS,
6858 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6859 },		/* 38 = stat43 */
6860 	{
6861 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6862 	},		/* 39 = getppid */
6863 	{
6864 		.sy_flags = SYCALL_NOSYS,
6865 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6866 },		/* 40 = lstat43 */
6867 	{
6868 		ns(struct sys_dup_args),
6869 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6870 	},		/* 41 = dup */
6871 	{
6872 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6873 	},		/* 42 = pipe */
6874 	{
6875 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6876 	},		/* 43 = getegid */
6877 	{
6878 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6879 },		/* 44 = profil */
6880 	{
6881 		ns(struct sys_ktrace_args),
6882 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6883 	},		/* 45 = ktrace */
6884 	{
6885 		.sy_flags = SYCALL_NOSYS,
6886 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6887 },		/* 46 = sigaction13 */
6888 	{
6889 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6890 	},		/* 47 = getgid */
6891 	{
6892 		.sy_flags = SYCALL_NOSYS,
6893 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6894 },		/* 48 = sigprocmask13 */
6895 	{
6896 		ns(struct sys___getlogin_args),
6897 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6898 	},		/* 49 = __getlogin */
6899 	{
6900 		ns(struct sys___setlogin_args),
6901 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6902 	},		/* 50 = __setlogin */
6903 	{
6904 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6905 },		/* 51 = acct */
6906 	{
6907 		.sy_flags = SYCALL_NOSYS,
6908 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6909 },		/* 52 = sigpending13 */
6910 	{
6911 		.sy_flags = SYCALL_NOSYS,
6912 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6913 },		/* 53 = sigaltstack13 */
6914 	{
6915 		ns(struct sys_ioctl_args),
6916 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6917 	},		/* 54 = ioctl */
6918 	{
6919 		.sy_flags = SYCALL_NOSYS,
6920 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6921 },		/* 55 = oreboot */
6922 	{
6923 		ns(struct sys_revoke_args),
6924 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6925 	},		/* 56 = revoke */
6926 	{
6927 		ns(struct sys_symlink_args),
6928 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6929 	},		/* 57 = symlink */
6930 	{
6931 		ns(struct sys_readlink_args),
6932 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6933 	},		/* 58 = readlink */
6934 	{
6935 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6936 },		/* 59 = execve */
6937 	{
6938 		ns(struct sys_umask_args),
6939 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6940 	},		/* 60 = umask */
6941 	{
6942 		ns(struct sys_chroot_args),
6943 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6944 	},		/* 61 = chroot */
6945 	{
6946 		.sy_flags = SYCALL_NOSYS,
6947 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6948 },		/* 62 = fstat43 */
6949 	{
6950 		.sy_flags = SYCALL_NOSYS,
6951 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6952 },		/* 63 = ogetkerninfo */
6953 	{
6954 		.sy_flags = SYCALL_NOSYS,
6955 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6956 },		/* 64 = ogetpagesize */
6957 	{
6958 		.sy_flags = SYCALL_NOSYS,
6959 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6960 },		/* 65 = msync */
6961 	{
6962 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6963 },		/* 66 = vfork */
6964 	{
6965 		.sy_flags = SYCALL_NOSYS,
6966 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6967 	},		/* 67 = filler */
6968 	{
6969 		.sy_flags = SYCALL_NOSYS,
6970 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6971 	},		/* 68 = filler */
6972 	{
6973 		.sy_flags = SYCALL_NOSYS,
6974 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6975 	},		/* 69 = filler */
6976 	{
6977 		.sy_flags = SYCALL_NOSYS,
6978 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6979 	},		/* 70 = filler */
6980 	{
6981 		.sy_flags = SYCALL_NOSYS,
6982 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
6983 },		/* 71 = ommap */
6984 	{
6985 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6986 },		/* 72 = vadvise */
6987 	{
6988 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6989 },		/* 73 = munmap */
6990 	{
6991 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6992 },		/* 74 = mprotect */
6993 	{
6994 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6995 },		/* 75 = madvise */
6996 	{
6997 		.sy_flags = SYCALL_NOSYS,
6998 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
6999 	},		/* 76 = filler */
7000 	{
7001 		.sy_flags = SYCALL_NOSYS,
7002 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7003 	},		/* 77 = filler */
7004 	{
7005 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7006 },		/* 78 = mincore */
7007 	{
7008 		ns(struct sys_getgroups_args),
7009 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7010 	},		/* 79 = getgroups */
7011 	{
7012 		ns(struct sys_setgroups_args),
7013 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7014 	},		/* 80 = setgroups */
7015 	{
7016 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7017 	},		/* 81 = getpgrp */
7018 	{
7019 		ns(struct sys_setpgid_args),
7020 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7021 	},		/* 82 = setpgid */
7022 	{
7023 		.sy_flags = SYCALL_NOSYS,
7024 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7025 },		/* 83 = setitimer */
7026 	{
7027 		.sy_flags = SYCALL_NOSYS,
7028 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7029 },		/* 84 = owait */
7030 	{
7031 		.sy_flags = SYCALL_NOSYS,
7032 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7033 },		/* 85 = oswapon */
7034 	{
7035 		.sy_flags = SYCALL_NOSYS,
7036 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7037 },		/* 86 = getitimer */
7038 	{
7039 		.sy_flags = SYCALL_NOSYS,
7040 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7041 },		/* 87 = ogethostname */
7042 	{
7043 		.sy_flags = SYCALL_NOSYS,
7044 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7045 },		/* 88 = osethostname */
7046 	{
7047 		.sy_flags = SYCALL_NOSYS,
7048 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7049 },		/* 89 = ogetdtablesize */
7050 	{
7051 		ns(struct sys_dup2_args),
7052 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7053 	},		/* 90 = dup2 */
7054 	{
7055 		ns(struct sys_getrandom_args),
7056 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7057 	},		/* 91 = getrandom */
7058 	{
7059 		ns(struct sys_fcntl_args),
7060 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7061 	},		/* 92 = fcntl */
7062 	{
7063 		ns(struct compat_50_sys_select_args),
7064 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7065 	},		/* 93 = compat_50_select */
7066 	{
7067 		.sy_flags = SYCALL_NOSYS,
7068 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7069 	},		/* 94 = filler */
7070 	{
7071 		ns(struct sys_fsync_args),
7072 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7073 	},		/* 95 = fsync */
7074 	{
7075 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7076 },		/* 96 = setpriority */
7077 	{
7078 		.sy_flags = SYCALL_NOSYS,
7079 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7080 },		/* 97 = socket */
7081 	{
7082 		ns(struct sys_connect_args),
7083 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7084 	},		/* 98 = connect */
7085 	{
7086 		.sy_flags = SYCALL_NOSYS,
7087 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7088 },		/* 99 = oaccept */
7089 	{
7090 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7091 },		/* 100 = getpriority */
7092 	{
7093 		.sy_flags = SYCALL_NOSYS,
7094 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7095 },		/* 101 = osend */
7096 	{
7097 		.sy_flags = SYCALL_NOSYS,
7098 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7099 },		/* 102 = orecv */
7100 	{
7101 		.sy_flags = SYCALL_NOSYS,
7102 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7103 },		/* 103 = sigreturn13 */
7104 	{
7105 		ns(struct sys_bind_args),
7106 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7107 	},		/* 104 = bind */
7108 	{
7109 		ns(struct sys_setsockopt_args),
7110 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7111 	},		/* 105 = setsockopt */
7112 	{
7113 		ns(struct sys_listen_args),
7114 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7115 	},		/* 106 = listen */
7116 	{
7117 		.sy_flags = SYCALL_NOSYS,
7118 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7119 	},		/* 107 = filler */
7120 	{
7121 		.sy_flags = SYCALL_NOSYS,
7122 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7123 },		/* 108 = osigvec */
7124 	{
7125 		.sy_flags = SYCALL_NOSYS,
7126 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7127 },		/* 109 = osigblock */
7128 	{
7129 		.sy_flags = SYCALL_NOSYS,
7130 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7131 },		/* 110 = osigsetmask */
7132 	{
7133 		.sy_flags = SYCALL_NOSYS,
7134 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7135 },		/* 111 = sigsuspend13 */
7136 	{
7137 		.sy_flags = SYCALL_NOSYS,
7138 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7139 },		/* 112 = osigstack */
7140 	{
7141 		.sy_flags = SYCALL_NOSYS,
7142 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7143 },		/* 113 = orecvmsg */
7144 	{
7145 		.sy_flags = SYCALL_NOSYS,
7146 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7147 },		/* 114 = osendmsg */
7148 	{
7149 		.sy_flags = SYCALL_NOSYS,
7150 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7151 	},		/* 115 = filler */
7152 	{
7153 		.sy_flags = SYCALL_NOSYS,
7154 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7155 },		/* 116 = gettimeofday */
7156 	{
7157 		.sy_flags = SYCALL_NOSYS,
7158 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7159 },		/* 117 = getrusage */
7160 	{
7161 		ns(struct sys_getsockopt_args),
7162 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7163 	},		/* 118 = getsockopt */
7164 	{
7165 		.sy_flags = SYCALL_NOSYS,
7166 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7167 	},		/* 119 = filler */
7168 	{
7169 		ns(struct sys_readv_args),
7170 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7171 	},		/* 120 = readv */
7172 	{
7173 		ns(struct sys_writev_args),
7174 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7175 	},		/* 121 = writev */
7176 	{
7177 		.sy_flags = SYCALL_NOSYS,
7178 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7179 },		/* 122 = settimeofday */
7180 	{
7181 		ns(struct sys_fchown_args),
7182 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7183 	},		/* 123 = fchown */
7184 	{
7185 		ns(struct sys_fchmod_args),
7186 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7187 	},		/* 124 = fchmod */
7188 	{
7189 		.sy_flags = SYCALL_NOSYS,
7190 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7191 },		/* 125 = orecvfrom */
7192 	{
7193 		ns(struct sys_setreuid_args),
7194 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7195 	},		/* 126 = setreuid */
7196 	{
7197 		ns(struct sys_setregid_args),
7198 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7199 	},		/* 127 = setregid */
7200 	{
7201 		ns(struct sys_rename_args),
7202 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7203 	},		/* 128 = rename */
7204 	{
7205 		.sy_flags = SYCALL_NOSYS,
7206 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7207 },		/* 129 = otruncate */
7208 	{
7209 		.sy_flags = SYCALL_NOSYS,
7210 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7211 },		/* 130 = oftruncate */
7212 	{
7213 		ns(struct sys_flock_args),
7214 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7215 	},		/* 131 = flock */
7216 	{
7217 		ns(struct sys_mkfifo_args),
7218 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7219 	},		/* 132 = mkfifo */
7220 	{
7221 		ns(struct sys_sendto_args),
7222 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7223 	},		/* 133 = sendto */
7224 	{
7225 		ns(struct sys_shutdown_args),
7226 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7227 	},		/* 134 = shutdown */
7228 	{
7229 		ns(struct sys_socketpair_args),
7230 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7231 	},		/* 135 = socketpair */
7232 	{
7233 		ns(struct sys_mkdir_args),
7234 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7235 	},		/* 136 = mkdir */
7236 	{
7237 		ns(struct sys_rmdir_args),
7238 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7239 	},		/* 137 = rmdir */
7240 	{
7241 		ns(struct compat_50_sys_utimes_args),
7242 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7243 	},		/* 138 = compat_50_utimes */
7244 	{
7245 		.sy_flags = SYCALL_NOSYS,
7246 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7247 	},		/* 139 = filler */
7248 	{
7249 		.sy_flags = SYCALL_NOSYS,
7250 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7251 },		/* 140 = adjtime */
7252 	{
7253 		.sy_flags = SYCALL_NOSYS,
7254 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7255 },		/* 141 = ogetpeername */
7256 	{
7257 		.sy_flags = SYCALL_NOSYS,
7258 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7259 },		/* 142 = ogethostid */
7260 	{
7261 		.sy_flags = SYCALL_NOSYS,
7262 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7263 },		/* 143 = osethostid */
7264 	{
7265 		.sy_flags = SYCALL_NOSYS,
7266 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7267 },		/* 144 = ogetrlimit */
7268 	{
7269 		.sy_flags = SYCALL_NOSYS,
7270 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7271 },		/* 145 = osetrlimit */
7272 	{
7273 		.sy_flags = SYCALL_NOSYS,
7274 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7275 },		/* 146 = okillpg */
7276 	{
7277 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7278 	},		/* 147 = setsid */
7279 	{
7280 		.sy_flags = SYCALL_NOSYS,
7281 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7282 },		/* 148 = quotactl */
7283 	{
7284 		.sy_flags = SYCALL_NOSYS,
7285 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7286 },		/* 149 = oquota */
7287 	{
7288 		.sy_flags = SYCALL_NOSYS,
7289 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7290 },		/* 150 = ogetsockname */
7291 	{
7292 		.sy_flags = SYCALL_NOSYS,
7293 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7294 	},		/* 151 = filler */
7295 	{
7296 		.sy_flags = SYCALL_NOSYS,
7297 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7298 	},		/* 152 = filler */
7299 	{
7300 		.sy_flags = SYCALL_NOSYS,
7301 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7302 	},		/* 153 = filler */
7303 	{
7304 		.sy_flags = SYCALL_NOSYS,
7305 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7306 	},		/* 154 = filler */
7307 	{
7308 		ns(struct sys_nfssvc_args),
7309 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7310 	},		/* 155 = nfssvc */
7311 	{
7312 		.sy_flags = SYCALL_NOSYS,
7313 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7314 },		/* 156 = ogetdirentries */
7315 	{
7316 		.sy_flags = SYCALL_NOSYS,
7317 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7318 },		/* 157 = statfs */
7319 	{
7320 		.sy_flags = SYCALL_NOSYS,
7321 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7322 },		/* 158 = fstatfs */
7323 	{
7324 		.sy_flags = SYCALL_NOSYS,
7325 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7326 	},		/* 159 = filler */
7327 	{
7328 		.sy_flags = SYCALL_NOSYS,
7329 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7330 	},		/* 160 = filler */
7331 	{
7332 		.sy_flags = SYCALL_NOSYS,
7333 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7334 },		/* 161 = getfh */
7335 	{
7336 		.sy_flags = SYCALL_NOSYS,
7337 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7338 },		/* 162 = ogetdomainname */
7339 	{
7340 		.sy_flags = SYCALL_NOSYS,
7341 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7342 },		/* 163 = osetdomainname */
7343 	{
7344 		.sy_flags = SYCALL_NOSYS,
7345 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7346 },		/* 164 = ouname */
7347 	{
7348 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7349 },		/* 165 = sysarch */
7350 	{
7351 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7352 },		/* 166 = __futex */
7353 	{
7354 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7355 },		/* 167 = __futex_set_robust_list */
7356 	{
7357 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7358 },		/* 168 = __futex_get_robust_list */
7359 #if !defined(_LP64)
7360 	{
7361 		.sy_flags = SYCALL_NOSYS,
7362 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7363 },		/* 169 = osemsys */
7364 #else
7365 	{
7366 		.sy_flags = SYCALL_NOSYS,
7367 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7368 	},		/* 169 = filler */
7369 #endif
7370 #if !defined(_LP64)
7371 	{
7372 		.sy_flags = SYCALL_NOSYS,
7373 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7374 },		/* 170 = omsgsys */
7375 #else
7376 	{
7377 		.sy_flags = SYCALL_NOSYS,
7378 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7379 	},		/* 170 = filler */
7380 #endif
7381 #if !defined(_LP64)
7382 	{
7383 		.sy_flags = SYCALL_NOSYS,
7384 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7385 },		/* 171 = oshmsys */
7386 #else
7387 	{
7388 		.sy_flags = SYCALL_NOSYS,
7389 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7390 	},		/* 171 = filler */
7391 #endif
7392 	{
7393 		.sy_flags = SYCALL_NOSYS,
7394 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7395 	},		/* 172 = filler */
7396 	{
7397 		ns(struct sys_pread_args),
7398 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7399 	},		/* 173 = pread */
7400 	{
7401 		ns(struct sys_pwrite_args),
7402 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7403 	},		/* 174 = pwrite */
7404 	{
7405 		.sy_flags = SYCALL_NOSYS,
7406 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7407 },		/* 175 = ntp_gettime */
7408 #if defined(NTP) || !defined(_KERNEL_OPT)
7409 	{
7410 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7411 },		/* 176 = ntp_adjtime */
7412 #else
7413 	{
7414 		.sy_flags = SYCALL_NOSYS,
7415 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7416 	},		/* 176 = filler */
7417 #endif
7418 	{
7419 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7420 },		/* 177 = timerfd_create */
7421 	{
7422 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7423 },		/* 178 = timerfd_settime */
7424 	{
7425 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7426 },		/* 179 = timerfd_gettime */
7427 	{
7428 		.sy_flags = SYCALL_NOSYS,
7429 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7430 	},		/* 180 = filler */
7431 	{
7432 		ns(struct sys_setgid_args),
7433 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7434 	},		/* 181 = setgid */
7435 	{
7436 		ns(struct sys_setegid_args),
7437 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7438 	},		/* 182 = setegid */
7439 	{
7440 		ns(struct sys_seteuid_args),
7441 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7442 	},		/* 183 = seteuid */
7443 	{
7444 		.sy_flags = SYCALL_NOSYS,
7445 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7446 },		/* 184 = lfs_bmapv */
7447 	{
7448 		.sy_flags = SYCALL_NOSYS,
7449 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7450 },		/* 185 = lfs_markv */
7451 	{
7452 		.sy_flags = SYCALL_NOSYS,
7453 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7454 },		/* 186 = lfs_segclean */
7455 	{
7456 		.sy_flags = SYCALL_NOSYS,
7457 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7458 },		/* 187 = lfs_segwait */
7459 	{
7460 		.sy_flags = SYCALL_NOSYS,
7461 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7462 },		/* 188 = stat12 */
7463 	{
7464 		.sy_flags = SYCALL_NOSYS,
7465 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7466 },		/* 189 = fstat12 */
7467 	{
7468 		.sy_flags = SYCALL_NOSYS,
7469 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7470 },		/* 190 = lstat12 */
7471 	{
7472 		ns(struct sys_pathconf_args),
7473 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7474 	},		/* 191 = pathconf */
7475 	{
7476 		ns(struct sys_fpathconf_args),
7477 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7478 	},		/* 192 = fpathconf */
7479 	{
7480 		ns(struct sys_getsockopt2_args),
7481 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7482 	},		/* 193 = getsockopt2 */
7483 	{
7484 		ns(struct sys_getrlimit_args),
7485 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7486 	},		/* 194 = getrlimit */
7487 	{
7488 		ns(struct sys_setrlimit_args),
7489 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7490 	},		/* 195 = setrlimit */
7491 	{
7492 		.sy_flags = SYCALL_NOSYS,
7493 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7494 },		/* 196 = getdirentries */
7495 	{
7496 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7497 },		/* 197 = mmap */
7498 	{
7499 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7500 },		/* 198 = __syscall */
7501 	{
7502 		ns(struct sys_lseek_args),
7503 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7504 	},		/* 199 = lseek */
7505 	{
7506 		ns(struct sys_truncate_args),
7507 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7508 	},		/* 200 = truncate */
7509 	{
7510 		ns(struct sys_ftruncate_args),
7511 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7512 	},		/* 201 = ftruncate */
7513 	{
7514 		ns(struct sys___sysctl_args),
7515 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7516 	},		/* 202 = __sysctl */
7517 	{
7518 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7519 },		/* 203 = mlock */
7520 	{
7521 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7522 },		/* 204 = munlock */
7523 	{
7524 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7525 },		/* 205 = undelete */
7526 	{
7527 		ns(struct compat_50_sys_futimes_args),
7528 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7529 	},		/* 206 = compat_50_futimes */
7530 	{
7531 		ns(struct sys_getpgid_args),
7532 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7533 	},		/* 207 = getpgid */
7534 	{
7535 		ns(struct sys_reboot_args),
7536 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7537 	},		/* 208 = reboot */
7538 	{
7539 		ns(struct sys_poll_args),
7540 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7541 	},		/* 209 = poll */
7542 	{
7543 		.sy_flags = SYCALL_NOSYS,
7544 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7545 },		/* 210 = afssys */
7546 	{
7547 		.sy_flags = SYCALL_NOSYS,
7548 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7549 	},		/* 211 = filler */
7550 	{
7551 		.sy_flags = SYCALL_NOSYS,
7552 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7553 	},		/* 212 = filler */
7554 	{
7555 		.sy_flags = SYCALL_NOSYS,
7556 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7557 	},		/* 213 = filler */
7558 	{
7559 		.sy_flags = SYCALL_NOSYS,
7560 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7561 	},		/* 214 = filler */
7562 	{
7563 		.sy_flags = SYCALL_NOSYS,
7564 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7565 	},		/* 215 = filler */
7566 	{
7567 		.sy_flags = SYCALL_NOSYS,
7568 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7569 	},		/* 216 = filler */
7570 	{
7571 		.sy_flags = SYCALL_NOSYS,
7572 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7573 	},		/* 217 = filler */
7574 	{
7575 		.sy_flags = SYCALL_NOSYS,
7576 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7577 	},		/* 218 = filler */
7578 	{
7579 		.sy_flags = SYCALL_NOSYS,
7580 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7581 	},		/* 219 = filler */
7582 	{
7583 		.sy_flags = SYCALL_NOSYS,
7584 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7585 },		/* 220 = __semctl */
7586 	{
7587 		.sy_flags = SYCALL_NOSYS,
7588 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7589 },		/* 221 = semget */
7590 	{
7591 		.sy_flags = SYCALL_NOSYS,
7592 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7593 },		/* 222 = semop */
7594 	{
7595 		.sy_flags = SYCALL_NOSYS,
7596 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7597 },		/* 223 = semconfig */
7598 	{
7599 		.sy_flags = SYCALL_NOSYS,
7600 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7601 },		/* 224 = msgctl */
7602 	{
7603 		.sy_flags = SYCALL_NOSYS,
7604 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7605 },		/* 225 = msgget */
7606 	{
7607 		.sy_flags = SYCALL_NOSYS,
7608 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7609 },		/* 226 = msgsnd */
7610 	{
7611 		.sy_flags = SYCALL_NOSYS,
7612 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7613 },		/* 227 = msgrcv */
7614 	{
7615 		.sy_flags = SYCALL_NOSYS,
7616 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7617 },		/* 228 = shmat */
7618 	{
7619 		.sy_flags = SYCALL_NOSYS,
7620 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7621 },		/* 229 = shmctl */
7622 	{
7623 		.sy_flags = SYCALL_NOSYS,
7624 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7625 },		/* 230 = shmdt */
7626 	{
7627 		.sy_flags = SYCALL_NOSYS,
7628 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7629 },		/* 231 = shmget */
7630 	{
7631 		.sy_flags = SYCALL_NOSYS,
7632 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7633 },		/* 232 = clock_gettime */
7634 	{
7635 		.sy_flags = SYCALL_NOSYS,
7636 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7637 },		/* 233 = clock_settime */
7638 	{
7639 		.sy_flags = SYCALL_NOSYS,
7640 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7641 },		/* 234 = clock_getres */
7642 	{
7643 		ns(struct sys_timer_create_args),
7644 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7645 	},		/* 235 = timer_create */
7646 	{
7647 		ns(struct sys_timer_delete_args),
7648 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7649 	},		/* 236 = timer_delete */
7650 	{
7651 		.sy_flags = SYCALL_NOSYS,
7652 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7653 },		/* 237 = timer_settime */
7654 	{
7655 		.sy_flags = SYCALL_NOSYS,
7656 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7657 },		/* 238 = timer_gettime */
7658 	{
7659 		ns(struct sys_timer_getoverrun_args),
7660 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7661 	},		/* 239 = timer_getoverrun */
7662 	{
7663 		.sy_flags = SYCALL_NOSYS,
7664 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7665 },		/* 240 = nanosleep */
7666 	{
7667 		ns(struct sys_fdatasync_args),
7668 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7669 	},		/* 241 = fdatasync */
7670 	{
7671 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7672 },		/* 242 = mlockall */
7673 	{
7674 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7675 },		/* 243 = munlockall */
7676 	{
7677 		.sy_flags = SYCALL_NOSYS,
7678 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7679 },		/* 244 = __sigtimedwait */
7680 	{
7681 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7682 },		/* 245 = sigqueueinfo */
7683 	{
7684 		ns(struct sys_modctl_args),
7685 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7686 	},		/* 246 = modctl */
7687 	{
7688 		ns(struct sys__ksem_init_args),
7689 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7690 	},		/* 247 = _ksem_init */
7691 	{
7692 		ns(struct sys__ksem_open_args),
7693 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7694 	},		/* 248 = _ksem_open */
7695 	{
7696 		ns(struct sys__ksem_unlink_args),
7697 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7698 	},		/* 249 = _ksem_unlink */
7699 	{
7700 		ns(struct sys__ksem_close_args),
7701 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7702 	},		/* 250 = _ksem_close */
7703 	{
7704 		ns(struct sys__ksem_post_args),
7705 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7706 	},		/* 251 = _ksem_post */
7707 	{
7708 		ns(struct sys__ksem_wait_args),
7709 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7710 	},		/* 252 = _ksem_wait */
7711 	{
7712 		ns(struct sys__ksem_trywait_args),
7713 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7714 	},		/* 253 = _ksem_trywait */
7715 	{
7716 		ns(struct sys__ksem_getvalue_args),
7717 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7718 	},		/* 254 = _ksem_getvalue */
7719 	{
7720 		ns(struct sys__ksem_destroy_args),
7721 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7722 	},		/* 255 = _ksem_destroy */
7723 	{
7724 		ns(struct sys__ksem_timedwait_args),
7725 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7726 	},		/* 256 = _ksem_timedwait */
7727 	{
7728 		.sy_flags = SYCALL_NOSYS,
7729 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7730 },		/* 257 = mq_open */
7731 	{
7732 		.sy_flags = SYCALL_NOSYS,
7733 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7734 },		/* 258 = mq_close */
7735 	{
7736 		.sy_flags = SYCALL_NOSYS,
7737 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7738 },		/* 259 = mq_unlink */
7739 	{
7740 		.sy_flags = SYCALL_NOSYS,
7741 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7742 },		/* 260 = mq_getattr */
7743 	{
7744 		.sy_flags = SYCALL_NOSYS,
7745 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7746 },		/* 261 = mq_setattr */
7747 	{
7748 		.sy_flags = SYCALL_NOSYS,
7749 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7750 },		/* 262 = mq_notify */
7751 	{
7752 		.sy_flags = SYCALL_NOSYS,
7753 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7754 },		/* 263 = mq_send */
7755 	{
7756 		.sy_flags = SYCALL_NOSYS,
7757 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7758 },		/* 264 = mq_receive */
7759 	{
7760 		.sy_flags = SYCALL_NOSYS,
7761 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7762 },		/* 265 = mq_timedsend */
7763 	{
7764 		.sy_flags = SYCALL_NOSYS,
7765 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7766 },		/* 266 = mq_timedreceive */
7767 	{
7768 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7769 },		/* 267 = eventfd */
7770 	{
7771 		.sy_flags = SYCALL_NOSYS,
7772 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7773 	},		/* 268 = filler */
7774 	{
7775 		.sy_flags = SYCALL_NOSYS,
7776 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7777 	},		/* 269 = filler */
7778 	{
7779 		ns(struct sys___posix_rename_args),
7780 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7781 	},		/* 270 = __posix_rename */
7782 	{
7783 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7784 },		/* 271 = swapctl */
7785 	{
7786 		.sy_flags = SYCALL_NOSYS,
7787 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7788 },		/* 272 = getdents */
7789 	{
7790 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7791 },		/* 273 = minherit */
7792 	{
7793 		ns(struct sys_lchmod_args),
7794 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7795 	},		/* 274 = lchmod */
7796 	{
7797 		ns(struct sys_lchown_args),
7798 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7799 	},		/* 275 = lchown */
7800 	{
7801 		ns(struct compat_50_sys_lutimes_args),
7802 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7803 	},		/* 276 = compat_50_lutimes */
7804 	{
7805 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7806 },		/* 277 = __msync13 */
7807 	{
7808 		.sy_flags = SYCALL_NOSYS,
7809 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7810 },		/* 278 = __stat13 */
7811 	{
7812 		.sy_flags = SYCALL_NOSYS,
7813 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7814 },		/* 279 = __fstat13 */
7815 	{
7816 		.sy_flags = SYCALL_NOSYS,
7817 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7818 },		/* 280 = __lstat13 */
7819 	{
7820 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7821 },		/* 281 = __sigaltstack14 */
7822 	{
7823 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7824 },		/* 282 = __vfork14 */
7825 	{
7826 		ns(struct sys___posix_chown_args),
7827 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7828 	},		/* 283 = __posix_chown */
7829 	{
7830 		ns(struct sys___posix_fchown_args),
7831 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7832 	},		/* 284 = __posix_fchown */
7833 	{
7834 		ns(struct sys___posix_lchown_args),
7835 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7836 	},		/* 285 = __posix_lchown */
7837 	{
7838 		ns(struct sys_getsid_args),
7839 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7840 	},		/* 286 = getsid */
7841 	{
7842 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7843 },		/* 287 = __clone */
7844 	{
7845 		ns(struct sys_fktrace_args),
7846 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7847 	},		/* 288 = fktrace */
7848 	{
7849 		ns(struct sys_preadv_args),
7850 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7851 	},		/* 289 = preadv */
7852 	{
7853 		ns(struct sys_pwritev_args),
7854 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7855 	},		/* 290 = pwritev */
7856 	{
7857 		.sy_flags = SYCALL_NOSYS,
7858 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7859 },		/* 291 = __sigaction14 */
7860 	{
7861 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7862 },		/* 292 = __sigpending14 */
7863 	{
7864 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7865 },		/* 293 = __sigprocmask14 */
7866 	{
7867 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7868 },		/* 294 = __sigsuspend14 */
7869 	{
7870 		.sy_flags = SYCALL_NOSYS,
7871 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7872 },		/* 295 = __sigreturn14 */
7873 	{
7874 		ns(struct sys___getcwd_args),
7875 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7876 	},		/* 296 = __getcwd */
7877 	{
7878 		ns(struct sys_fchroot_args),
7879 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7880 	},		/* 297 = fchroot */
7881 	{
7882 		.sy_flags = SYCALL_NOSYS,
7883 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7884 },		/* 298 = fhopen */
7885 	{
7886 		.sy_flags = SYCALL_NOSYS,
7887 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7888 },		/* 299 = fhstat */
7889 	{
7890 		.sy_flags = SYCALL_NOSYS,
7891 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7892 },		/* 300 = fhstatfs */
7893 	{
7894 		.sy_flags = SYCALL_NOSYS,
7895 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7896 },		/* 301 = ____semctl13 */
7897 	{
7898 		.sy_flags = SYCALL_NOSYS,
7899 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7900 },		/* 302 = __msgctl13 */
7901 	{
7902 		.sy_flags = SYCALL_NOSYS,
7903 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7904 },		/* 303 = __shmctl13 */
7905 	{
7906 		ns(struct sys_lchflags_args),
7907 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7908 	},		/* 304 = lchflags */
7909 	{
7910 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7911 	},		/* 305 = issetugid */
7912 	{
7913 		ns(struct sys_utrace_args),
7914 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7915 	},		/* 306 = utrace */
7916 	{
7917 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7918 },		/* 307 = getcontext */
7919 	{
7920 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7921 },		/* 308 = setcontext */
7922 	{
7923 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7924 },		/* 309 = _lwp_create */
7925 	{
7926 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7927 },		/* 310 = _lwp_exit */
7928 	{
7929 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7930 },		/* 311 = _lwp_self */
7931 	{
7932 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7933 },		/* 312 = _lwp_wait */
7934 	{
7935 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7936 },		/* 313 = _lwp_suspend */
7937 	{
7938 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7939 },		/* 314 = _lwp_continue */
7940 	{
7941 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7942 },		/* 315 = _lwp_wakeup */
7943 	{
7944 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7945 },		/* 316 = _lwp_getprivate */
7946 	{
7947 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7948 },		/* 317 = _lwp_setprivate */
7949 	{
7950 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7951 },		/* 318 = _lwp_kill */
7952 	{
7953 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7954 },		/* 319 = _lwp_detach */
7955 	{
7956 		.sy_flags = SYCALL_NOSYS,
7957 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7958 },		/* 320 = _lwp_park */
7959 	{
7960 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7961 },		/* 321 = _lwp_unpark */
7962 	{
7963 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7964 },		/* 322 = _lwp_unpark_all */
7965 	{
7966 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7967 },		/* 323 = _lwp_setname */
7968 	{
7969 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7970 },		/* 324 = _lwp_getname */
7971 	{
7972 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7973 },		/* 325 = _lwp_ctl */
7974 	{
7975 		.sy_flags = SYCALL_NOSYS,
7976 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7977 	},		/* 326 = filler */
7978 	{
7979 		.sy_flags = SYCALL_NOSYS,
7980 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7981 	},		/* 327 = filler */
7982 	{
7983 		.sy_flags = SYCALL_NOSYS,
7984 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7985 	},		/* 328 = filler */
7986 	{
7987 		.sy_flags = SYCALL_NOSYS,
7988 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
7989 	},		/* 329 = filler */
7990 	{
7991 		.sy_flags = SYCALL_NOSYS,
7992 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7993 },		/* 330 = sa_register */
7994 	{
7995 		.sy_flags = SYCALL_NOSYS,
7996 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
7997 },		/* 331 = sa_stacks */
7998 	{
7999 		.sy_flags = SYCALL_NOSYS,
8000 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8001 },		/* 332 = sa_enable */
8002 	{
8003 		.sy_flags = SYCALL_NOSYS,
8004 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8005 },		/* 333 = sa_setconcurrency */
8006 	{
8007 		.sy_flags = SYCALL_NOSYS,
8008 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8009 },		/* 334 = sa_yield */
8010 	{
8011 		.sy_flags = SYCALL_NOSYS,
8012 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8013 },		/* 335 = sa_preempt */
8014 	{
8015 		.sy_flags = SYCALL_NOSYS,
8016 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8017 	},		/* 336 = filler */
8018 	{
8019 		.sy_flags = SYCALL_NOSYS,
8020 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8021 	},		/* 337 = filler */
8022 	{
8023 		.sy_flags = SYCALL_NOSYS,
8024 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8025 	},		/* 338 = filler */
8026 	{
8027 		.sy_flags = SYCALL_NOSYS,
8028 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8029 	},		/* 339 = filler */
8030 	{
8031 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8032 },		/* 340 = __sigaction_sigtramp */
8033 	{
8034 		.sy_flags = SYCALL_NOSYS,
8035 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8036 	},		/* 341 = filler */
8037 	{
8038 		.sy_flags = SYCALL_NOSYS,
8039 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8040 	},		/* 342 = filler */
8041 	{
8042 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8043 },		/* 343 = rasctl */
8044 	{
8045 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8046 	},		/* 344 = kqueue */
8047 	{
8048 		ns(struct compat_50_sys_kevent_args),
8049 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8050 	},		/* 345 = compat_50_kevent */
8051 	{
8052 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8053 },		/* 346 = _sched_setparam */
8054 	{
8055 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8056 },		/* 347 = _sched_getparam */
8057 	{
8058 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8059 },		/* 348 = _sched_setaffinity */
8060 	{
8061 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8062 },		/* 349 = _sched_getaffinity */
8063 	{
8064 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8065 },		/* 350 = sched_yield */
8066 	{
8067 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8068 },		/* 351 = _sched_protect */
8069 	{
8070 		.sy_flags = SYCALL_NOSYS,
8071 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8072 	},		/* 352 = filler */
8073 	{
8074 		.sy_flags = SYCALL_NOSYS,
8075 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8076 	},		/* 353 = filler */
8077 	{
8078 		ns(struct sys_fsync_range_args),
8079 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8080 	},		/* 354 = fsync_range */
8081 	{
8082 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8083 },		/* 355 = uuidgen */
8084 	{
8085 		.sy_flags = SYCALL_NOSYS,
8086 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8087 },		/* 356 = getvfsstat */
8088 	{
8089 		.sy_flags = SYCALL_NOSYS,
8090 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8091 },		/* 357 = statvfs1 */
8092 	{
8093 		.sy_flags = SYCALL_NOSYS,
8094 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8095 },		/* 358 = fstatvfs1 */
8096 	{
8097 		.sy_flags = SYCALL_NOSYS,
8098 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8099 },		/* 359 = fhstatvfs1 */
8100 	{
8101 		ns(struct sys_extattrctl_args),
8102 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8103 	},		/* 360 = extattrctl */
8104 	{
8105 		ns(struct sys_extattr_set_file_args),
8106 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8107 	},		/* 361 = extattr_set_file */
8108 	{
8109 		ns(struct sys_extattr_get_file_args),
8110 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8111 	},		/* 362 = extattr_get_file */
8112 	{
8113 		ns(struct sys_extattr_delete_file_args),
8114 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8115 	},		/* 363 = extattr_delete_file */
8116 	{
8117 		ns(struct sys_extattr_set_fd_args),
8118 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8119 	},		/* 364 = extattr_set_fd */
8120 	{
8121 		ns(struct sys_extattr_get_fd_args),
8122 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8123 	},		/* 365 = extattr_get_fd */
8124 	{
8125 		ns(struct sys_extattr_delete_fd_args),
8126 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8127 	},		/* 366 = extattr_delete_fd */
8128 	{
8129 		ns(struct sys_extattr_set_link_args),
8130 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8131 	},		/* 367 = extattr_set_link */
8132 	{
8133 		ns(struct sys_extattr_get_link_args),
8134 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8135 	},		/* 368 = extattr_get_link */
8136 	{
8137 		ns(struct sys_extattr_delete_link_args),
8138 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8139 	},		/* 369 = extattr_delete_link */
8140 	{
8141 		ns(struct sys_extattr_list_fd_args),
8142 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8143 	},		/* 370 = extattr_list_fd */
8144 	{
8145 		ns(struct sys_extattr_list_file_args),
8146 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8147 	},		/* 371 = extattr_list_file */
8148 	{
8149 		ns(struct sys_extattr_list_link_args),
8150 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8151 	},		/* 372 = extattr_list_link */
8152 	{
8153 		ns(struct compat_50_sys_pselect_args),
8154 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8155 	},		/* 373 = compat_50_pselect */
8156 	{
8157 		ns(struct compat_50_sys_pollts_args),
8158 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8159 	},		/* 374 = compat_50_pollts */
8160 	{
8161 		ns(struct sys_setxattr_args),
8162 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8163 	},		/* 375 = setxattr */
8164 	{
8165 		ns(struct sys_lsetxattr_args),
8166 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8167 	},		/* 376 = lsetxattr */
8168 	{
8169 		ns(struct sys_fsetxattr_args),
8170 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8171 	},		/* 377 = fsetxattr */
8172 	{
8173 		ns(struct sys_getxattr_args),
8174 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8175 	},		/* 378 = getxattr */
8176 	{
8177 		ns(struct sys_lgetxattr_args),
8178 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8179 	},		/* 379 = lgetxattr */
8180 	{
8181 		ns(struct sys_fgetxattr_args),
8182 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8183 	},		/* 380 = fgetxattr */
8184 	{
8185 		ns(struct sys_listxattr_args),
8186 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8187 	},		/* 381 = listxattr */
8188 	{
8189 		ns(struct sys_llistxattr_args),
8190 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8191 	},		/* 382 = llistxattr */
8192 	{
8193 		ns(struct sys_flistxattr_args),
8194 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8195 	},		/* 383 = flistxattr */
8196 	{
8197 		ns(struct sys_removexattr_args),
8198 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8199 	},		/* 384 = removexattr */
8200 	{
8201 		ns(struct sys_lremovexattr_args),
8202 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8203 	},		/* 385 = lremovexattr */
8204 	{
8205 		ns(struct sys_fremovexattr_args),
8206 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8207 	},		/* 386 = fremovexattr */
8208 	{
8209 		ns(struct compat_50_sys___stat30_args),
8210 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8211 	},		/* 387 = compat_50___stat30 */
8212 	{
8213 		ns(struct compat_50_sys___fstat30_args),
8214 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8215 	},		/* 388 = compat_50___fstat30 */
8216 	{
8217 		ns(struct compat_50_sys___lstat30_args),
8218 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8219 	},		/* 389 = compat_50___lstat30 */
8220 	{
8221 		ns(struct sys___getdents30_args),
8222 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8223 	},		/* 390 = __getdents30 */
8224 	{
8225 		.sy_flags = SYCALL_NOSYS,
8226 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8227 	},		/* 391 = filler */
8228 	{
8229 		.sy_flags = SYCALL_NOSYS,
8230 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8231 },		/* 392 = __fhstat30 */
8232 	{
8233 		.sy_flags = SYCALL_NOSYS,
8234 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8235 },		/* 393 = __ntp_gettime30 */
8236 	{
8237 		ns(struct sys___socket30_args),
8238 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8239 	},		/* 394 = __socket30 */
8240 	{
8241 		ns(struct sys___getfh30_args),
8242 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8243 	},		/* 395 = __getfh30 */
8244 	{
8245 		ns(struct sys___fhopen40_args),
8246 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8247 	},		/* 396 = __fhopen40 */
8248 	{
8249 		.sy_flags = SYCALL_NOSYS,
8250 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8251 },		/* 397 = fhstatvfs1 */
8252 	{
8253 		ns(struct compat_50_sys___fhstat40_args),
8254 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8255 	},		/* 398 = compat_50___fhstat40 */
8256 	{
8257 		ns(struct sys_aio_cancel_args),
8258 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8259 	},		/* 399 = aio_cancel */
8260 	{
8261 		ns(struct sys_aio_error_args),
8262 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8263 	},		/* 400 = aio_error */
8264 	{
8265 		ns(struct sys_aio_fsync_args),
8266 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8267 	},		/* 401 = aio_fsync */
8268 	{
8269 		ns(struct sys_aio_read_args),
8270 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8271 	},		/* 402 = aio_read */
8272 	{
8273 		ns(struct sys_aio_return_args),
8274 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8275 	},		/* 403 = aio_return */
8276 	{
8277 		.sy_flags = SYCALL_NOSYS,
8278 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8279 },		/* 404 = aio_suspend */
8280 	{
8281 		ns(struct sys_aio_write_args),
8282 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8283 	},		/* 405 = aio_write */
8284 	{
8285 		ns(struct sys_lio_listio_args),
8286 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8287 	},		/* 406 = lio_listio */
8288 	{
8289 		.sy_flags = SYCALL_NOSYS,
8290 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8291 	},		/* 407 = filler */
8292 	{
8293 		.sy_flags = SYCALL_NOSYS,
8294 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8295 	},		/* 408 = filler */
8296 	{
8297 		.sy_flags = SYCALL_NOSYS,
8298 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8299 	},		/* 409 = filler */
8300 	{
8301 		ns(struct sys___mount50_args),
8302 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8303 	},		/* 410 = __mount50 */
8304 	{
8305 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8306 },		/* 411 = mremap */
8307 	{
8308 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8309 },		/* 412 = pset_create */
8310 	{
8311 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8312 },		/* 413 = pset_destroy */
8313 	{
8314 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8315 },		/* 414 = pset_assign */
8316 	{
8317 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8318 },		/* 415 = _pset_bind */
8319 	{
8320 		ns(struct sys___posix_fadvise50_args),
8321 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8322 	},		/* 416 = __posix_fadvise50 */
8323 	{
8324 		ns(struct sys___select50_args),
8325 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8326 	},		/* 417 = __select50 */
8327 	{
8328 		ns(struct sys___gettimeofday50_args),
8329 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8330 	},		/* 418 = __gettimeofday50 */
8331 	{
8332 		ns(struct sys___settimeofday50_args),
8333 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8334 	},		/* 419 = __settimeofday50 */
8335 	{
8336 		ns(struct sys___utimes50_args),
8337 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8338 	},		/* 420 = __utimes50 */
8339 	{
8340 		ns(struct sys___adjtime50_args),
8341 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8342 	},		/* 421 = __adjtime50 */
8343 	{
8344 		.sy_flags = SYCALL_NOSYS,
8345 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8346 },		/* 422 = __lfs_segwait50 */
8347 	{
8348 		ns(struct sys___futimes50_args),
8349 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8350 	},		/* 423 = __futimes50 */
8351 	{
8352 		ns(struct sys___lutimes50_args),
8353 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8354 	},		/* 424 = __lutimes50 */
8355 	{
8356 		ns(struct sys___setitimer50_args),
8357 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8358 	},		/* 425 = __setitimer50 */
8359 	{
8360 		ns(struct sys___getitimer50_args),
8361 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8362 	},		/* 426 = __getitimer50 */
8363 	{
8364 		ns(struct sys___clock_gettime50_args),
8365 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8366 	},		/* 427 = __clock_gettime50 */
8367 	{
8368 		ns(struct sys___clock_settime50_args),
8369 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8370 	},		/* 428 = __clock_settime50 */
8371 	{
8372 		ns(struct sys___clock_getres50_args),
8373 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8374 	},		/* 429 = __clock_getres50 */
8375 	{
8376 		ns(struct sys___nanosleep50_args),
8377 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8378 	},		/* 430 = __nanosleep50 */
8379 	{
8380 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8381 },		/* 431 = ____sigtimedwait50 */
8382 	{
8383 		.sy_flags = SYCALL_NOSYS,
8384 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8385 },		/* 432 = __mq_timedsend50 */
8386 	{
8387 		.sy_flags = SYCALL_NOSYS,
8388 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8389 },		/* 433 = __mq_timedreceive50 */
8390 	{
8391 		.sy_flags = SYCALL_NOSYS,
8392 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8393 },		/* 434 = _lwp_park */
8394 	{
8395 		ns(struct compat_100_sys___kevent50_args),
8396 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8397 	},		/* 435 = compat_100___kevent50 */
8398 	{
8399 		ns(struct sys___pselect50_args),
8400 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8401 	},		/* 436 = __pselect50 */
8402 	{
8403 		ns(struct sys___pollts50_args),
8404 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8405 	},		/* 437 = __pollts50 */
8406 	{
8407 		ns(struct sys___aio_suspend50_args),
8408 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8409 	},		/* 438 = __aio_suspend50 */
8410 	{
8411 		ns(struct sys___stat50_args),
8412 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8413 	},		/* 439 = __stat50 */
8414 	{
8415 		ns(struct sys___fstat50_args),
8416 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8417 	},		/* 440 = __fstat50 */
8418 	{
8419 		ns(struct sys___lstat50_args),
8420 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8421 	},		/* 441 = __lstat50 */
8422 	{
8423 		.sy_flags = SYCALL_NOSYS,
8424 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8425 },		/* 442 = ____semctl50 */
8426 	{
8427 		.sy_flags = SYCALL_NOSYS,
8428 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8429 },		/* 443 = __shmctl50 */
8430 	{
8431 		.sy_flags = SYCALL_NOSYS,
8432 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8433 },		/* 444 = __msgctl50 */
8434 	{
8435 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8436 },		/* 445 = __getrusage50 */
8437 	{
8438 		ns(struct sys___timer_settime50_args),
8439 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8440 	},		/* 446 = __timer_settime50 */
8441 	{
8442 		ns(struct sys___timer_gettime50_args),
8443 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8444 	},		/* 447 = __timer_gettime50 */
8445 #if defined(NTP) || !defined(_KERNEL_OPT)
8446 	{
8447 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8448 },		/* 448 = __ntp_gettime50 */
8449 #else
8450 	{
8451 		.sy_flags = SYCALL_NOSYS,
8452 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8453 	},		/* 448 = filler */
8454 #endif
8455 	{
8456 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8457 },		/* 449 = __wait450 */
8458 	{
8459 		ns(struct sys___mknod50_args),
8460 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8461 	},		/* 450 = __mknod50 */
8462 	{
8463 		ns(struct sys___fhstat50_args),
8464 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8465 	},		/* 451 = __fhstat50 */
8466 	{
8467 		.sy_flags = SYCALL_NOSYS,
8468 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8469 	},		/* 452 = filler */
8470 	{
8471 		ns(struct sys_pipe2_args),
8472 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8473 	},		/* 453 = pipe2 */
8474 	{
8475 		ns(struct compat_100_sys_dup3_args),
8476 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8477 	},		/* 454 = compat_100_dup3 */
8478 	{
8479 		ns(struct sys_kqueue1_args),
8480 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8481 	},		/* 455 = kqueue1 */
8482 	{
8483 		ns(struct sys_paccept_args),
8484 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8485 	},		/* 456 = paccept */
8486 	{
8487 		ns(struct sys_linkat_args),
8488 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8489 	},		/* 457 = linkat */
8490 	{
8491 		ns(struct sys_renameat_args),
8492 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8493 	},		/* 458 = renameat */
8494 	{
8495 		ns(struct sys_mkfifoat_args),
8496 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8497 	},		/* 459 = mkfifoat */
8498 	{
8499 		ns(struct sys_mknodat_args),
8500 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8501 	},		/* 460 = mknodat */
8502 	{
8503 		ns(struct sys_mkdirat_args),
8504 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8505 	},		/* 461 = mkdirat */
8506 	{
8507 		ns(struct sys_faccessat_args),
8508 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8509 	},		/* 462 = faccessat */
8510 	{
8511 		ns(struct sys_fchmodat_args),
8512 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8513 	},		/* 463 = fchmodat */
8514 	{
8515 		ns(struct sys_fchownat_args),
8516 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8517 	},		/* 464 = fchownat */
8518 	{
8519 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8520 },		/* 465 = fexecve */
8521 	{
8522 		ns(struct sys_fstatat_args),
8523 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8524 	},		/* 466 = fstatat */
8525 	{
8526 		ns(struct sys_utimensat_args),
8527 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8528 	},		/* 467 = utimensat */
8529 	{
8530 		ns(struct sys_openat_args),
8531 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8532 	},		/* 468 = openat */
8533 	{
8534 		ns(struct sys_readlinkat_args),
8535 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8536 	},		/* 469 = readlinkat */
8537 	{
8538 		ns(struct sys_symlinkat_args),
8539 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8540 	},		/* 470 = symlinkat */
8541 	{
8542 		ns(struct sys_unlinkat_args),
8543 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8544 	},		/* 471 = unlinkat */
8545 	{
8546 		ns(struct sys_futimens_args),
8547 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8548 	},		/* 472 = futimens */
8549 	{
8550 		ns(struct sys___quotactl_args),
8551 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8552 	},		/* 473 = __quotactl */
8553 	{
8554 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8555 },		/* 474 = posix_spawn */
8556 	{
8557 		ns(struct sys_recvmmsg_args),
8558 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8559 	},		/* 475 = recvmmsg */
8560 	{
8561 		ns(struct sys_sendmmsg_args),
8562 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8563 	},		/* 476 = sendmmsg */
8564 	{
8565 		ns(struct sys_clock_nanosleep_args),
8566 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8567 	},		/* 477 = clock_nanosleep */
8568 	{
8569 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8570 },		/* 478 = ___lwp_park60 */
8571 	{
8572 		ns(struct sys_posix_fallocate_args),
8573 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8574 	},		/* 479 = posix_fallocate */
8575 	{
8576 		ns(struct sys_fdiscard_args),
8577 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8578 	},		/* 480 = fdiscard */
8579 	{
8580 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8581 },		/* 481 = wait6 */
8582 	{
8583 		ns(struct sys_clock_getcpuclockid2_args),
8584 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8585 	},		/* 482 = clock_getcpuclockid2 */
8586 	{
8587 		ns(struct sys___getvfsstat90_args),
8588 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8589 	},		/* 483 = __getvfsstat90 */
8590 	{
8591 		ns(struct sys___statvfs190_args),
8592 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8593 	},		/* 484 = __statvfs190 */
8594 	{
8595 		ns(struct sys___fstatvfs190_args),
8596 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8597 	},		/* 485 = __fstatvfs190 */
8598 	{
8599 		ns(struct sys___fhstatvfs190_args),
8600 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8601 	},		/* 486 = __fhstatvfs190 */
8602 	{
8603 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8604 },		/* 487 = __acl_get_link */
8605 	{
8606 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8607 },		/* 488 = __acl_set_link */
8608 	{
8609 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8610 },		/* 489 = __acl_delete_link */
8611 	{
8612 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8613 },		/* 490 = __acl_aclcheck_link */
8614 	{
8615 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8616 },		/* 491 = __acl_get_file */
8617 	{
8618 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8619 },		/* 492 = __acl_set_file */
8620 	{
8621 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8622 },		/* 493 = __acl_get_fd */
8623 	{
8624 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8625 },		/* 494 = __acl_set_fd */
8626 	{
8627 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8628 },		/* 495 = __acl_delete_file */
8629 	{
8630 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8631 },		/* 496 = __acl_delete_fd */
8632 	{
8633 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8634 },		/* 497 = __acl_aclcheck_file */
8635 	{
8636 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8637 },		/* 498 = __acl_aclcheck_fd */
8638 	{
8639 		ns(struct sys_lpathconf_args),
8640 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8641 	},		/* 499 = lpathconf */
8642 	{
8643 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8644 },		/* 500 = memfd_create */
8645 	{
8646 		ns(struct sys___kevent100_args),
8647 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8648 	},		/* 501 = __kevent100 */
8649 	{
8650 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8651 },		/* 502 = epoll_create1 */
8652 	{
8653 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8654 },		/* 503 = epoll_ctl */
8655 	{
8656 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8657 },		/* 504 = epoll_pwait2 */
8658 	{
8659 		ns(struct sys___dup3100_args),
8660 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8661 	},		/* 505 = __dup3100 */
8662 	{
8663 		.sy_flags = SYCALL_NOSYS,
8664 		.sy_call = (sy_call_t *)(void *)rumpns_sys_nomodule,
8665 },		/* 506 = semtimedop */
8666 	{
8667 		.sy_flags = SYCALL_NOSYS,
8668 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8669 	},		/* 507 = filler */
8670 	{
8671 		.sy_flags = SYCALL_NOSYS,
8672 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8673 	},		/* 508 = filler */
8674 	{
8675 		.sy_flags = SYCALL_NOSYS,
8676 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8677 	},		/* 509 = filler */
8678 	{
8679 		.sy_flags = SYCALL_NOSYS,
8680 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8681 	},		/* 510 = filler */
8682 	{
8683 		.sy_flags = SYCALL_NOSYS,
8684 		.sy_call = (sy_call_t *)(void *)rumpns_enosys,
8685 	},		/* 511 = filler */
8686 };
8687 
8688 const uint32_t rump_sysent_nomodbits[] = {
8689 	0x042c4180,	/* syscalls   0- 31 */
8690 	0xc0b14140,	/* syscalls  32- 63 */
8691 	0x23f80083,	/* syscalls  64- 95 */
8692 	0x2437f0ea,	/* syscalls  96-127 */
8693 	0x7877f406,	/* syscalls 128-159 */
8694 	0x7f008e1e,	/* syscalls 160-191 */
8695 	0xf0044010,	/* syscalls 192-223 */
8696 	0xff9167ff,	/* syscalls 224-255 */
8697 	0x01d107ff,	/* syscalls 256-287 */
8698 	0x0000fc88,	/* syscalls 288-319 */
8699 	0x0200fc01,	/* syscalls 320-351 */
8700 	0x006000f0,	/* syscalls 352-383 */
8701 	0x007fe338,	/* syscalls 384-415 */
8702 	0x1c4f0040,	/* syscalls 416-447 */
8703 	0x00000040,	/* syscalls 448-479 */
8704 	0x04000000,	/* syscalls 480-511 */
8705 };
8706 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT);
8707 __strong_alias(rumpns_sysent,rump_sysent);
8708 #endif /* RUMP_CLIENT */
8709