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