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