?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / compat / netbsd32 / netbsd32_netbsd.c
blobb5615f052375afe95e07d8622e4db77fd5688289
1 /* $NetBSD$ */
2
3 /*
4 * Copyright (c) 1998, 2001, 2008 Matthew R. Green
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD$");
31
32 #if defined(_KERNEL_OPT)
33 #include "opt_ddb.h"
34 #include "opt_ntp.h"
35 #include "opt_compat_netbsd.h"
36 #include "opt_compat_43.h"
37 #include "opt_sysv.h"
38 #include "opt_syscall_debug.h"
39 #include "opt_sa.h"
40
41 #include "fs_lfs.h"
42 #endif
43
44 /*
45 * Though COMPAT_OLDSOCK is needed only for COMPAT_43, SunOS, Linux,
46 * HP-UX, FreeBSD, Ultrix, OSF1, we define it unconditionally so that
47 * this would be module-safe.
48 */
49 #define COMPAT_OLDSOCK /* used by <sys/socket.h> */
50
51 #include <sys/param.h>
52 #include <sys/systm.h>
53 #include <sys/kernel.h>
54 //#define msg __msg /* Don't ask me! */
55 #include <sys/malloc.h>
56 #include <sys/mount.h>
57 #include <sys/socket.h>
58 #include <sys/sockio.h>
59 #include <sys/socketvar.h>
60 #include <sys/mbuf.h>
61 #include <sys/stat.h>
62 #include <sys/time.h>
63 #include <sys/signalvar.h>
64 #include <sys/ptrace.h>
65 #include <sys/ktrace.h>
66 #include <sys/trace.h>
67 #include <sys/resourcevar.h>
68 #include <sys/pool.h>
69 #include <sys/vnode.h>
70 #include <sys/file.h>
71 #include <sys/filedesc.h>
72 #include <sys/namei.h>
73 #include <sys/dirent.h>
74 #include <sys/kauth.h>
75 #include <sys/vfs_syscalls.h>
76
77 #include <uvm/uvm_extern.h>
78
79 #include <sys/sa.h>
80 #include <sys/savar.h>
81 #include <sys/syscallargs.h>
82 #include <sys/proc.h>
83 #include <sys/acct.h>
84 #include <sys/exec.h>
85
86 #include <net/if.h>
87
88 #include <compat/netbsd32/netbsd32.h>
89 #include <compat/netbsd32/netbsd32_exec.h>
90 #include <compat/netbsd32/netbsd32_syscall.h>
91 #include <compat/netbsd32/netbsd32_syscallargs.h>
92 #include <compat/netbsd32/netbsd32_conv.h>
93 #include <compat/netbsd32/netbsd32_sa.h>
94
95 #if defined(DDB)
96 #include <ddb/ddbvar.h>
97 #endif
98
99 extern struct sysent netbsd32_sysent[];
100 #ifdef SYSCALL_DEBUG
101 extern const char * const netbsd32_syscallnames[];
102 #endif
103 #ifdef __HAVE_SYSCALL_INTERN
104 void netbsd32_syscall_intern(struct proc *);
105 #else
106 void syscall(void);
107 #endif
108
109 #define LIMITCHECK(a, b) ((a) != RLIM_INFINITY && (a) > (b))
110
111 #ifdef COMPAT_16
112 extern char netbsd32_sigcode[], netbsd32_esigcode[];
113 struct uvm_object *emul_netbsd32_object;
114 #endif
115
116 extern struct sysctlnode netbsd32_sysctl_root;
117
118 struct emul emul_netbsd32 = {
119 .e_name = "netbsd32",
120 .e_path = "/emul/netbsd32",
121 #ifndef __HAVE_MINIMAL_EMUL
122 .e_flags = 0,
123 .e_errno = NULL,
124 .e_nosys = NETBSD32_SYS_netbsd32_syscall,
125 .e_nsysent = NETBSD32_SYS_NSYSENT,
126 #endif
127 .e_sysent = netbsd32_sysent,
128 #ifdef SYSCALL_DEBUG
129 .e_syscallnames = netbsd32_syscallnames,
130 #else
131 .e_syscallnames = NULL,
132 #endif
133 .e_sendsig = netbsd32_sendsig,
134 .e_trapsignal = trapsignal,
135 .e_tracesig = NULL,
136 #ifdef COMPAT_16
137 .e_sigcode = netbsd32_sigcode,
138 .e_esigcode = netbsd32_esigcode,
139 .e_sigobject = &emul_netbsd32_object,
140 #else
141 .e_sigcode = NULL,
142 .e_esigcode = NULL,
143 .e_sigobject = NULL,
144 #endif
145 .e_setregs = netbsd32_setregs,
146 .e_proc_exec = NULL,
147 .e_proc_fork = NULL,
148 .e_proc_exit = NULL,
149 .e_lwp_fork = NULL,
150 .e_lwp_exit = NULL,
151 #ifdef __HAVE_SYSCALL_INTERN
152 .e_syscall_intern = netbsd32_syscall_intern,
153 #else
154 .e_syscall = syscall,
155 #endif
156 .e_sysctlovly = &netbsd32_sysctl_root,
157 .e_fault = NULL,
158 .e_vm_default_addr = netbsd32_vm_default_addr,
159 .e_usertrap = NULL,
160 #if defined(COMPAT_40) && defined(KERN_SA)
161 .e_sa = &saemul_netbsd32,
162 #else
163 .e_sa = NULL,
164 #endif
165 .e_ucsize = sizeof(ucontext32_t),
166 .e_startlwp = startlwp32
167 };
168
169 /*
170 * below are all the standard NetBSD system calls, in the 32bit
171 * environment, with the necessary conversions to 64bit before
172 * calling the real syscall. anything that needs special
173 * attention is handled elsewhere.
174 */
175
176 int
177 netbsd32_exit(struct lwp *l, const struct netbsd32_exit_args *uap, register_t *retval)
178 {
179 /* {
180 syscallarg(int) rval;
181 } */
182 struct sys_exit_args ua;
183
184 NETBSD32TO64_UAP(rval);
185 return sys_exit(l, &ua, retval);
186 }
187
188 int
189 netbsd32_read(struct lwp *l, const struct netbsd32_read_args *uap, register_t *retval)
190 {
191 /* {
192 syscallarg(int) fd;
193 syscallarg(netbsd32_voidp) buf;
194 syscallarg(netbsd32_size_t) nbyte;
195 } */
196 struct sys_read_args ua;
197
198 NETBSD32TO64_UAP(fd);
199 NETBSD32TOP_UAP(buf, void *);
200 NETBSD32TOX_UAP(nbyte, size_t);
201 return sys_read(l, &ua, retval);
202 }
203
204 int
205 netbsd32_write(struct lwp *l, const struct netbsd32_write_args *uap, register_t *retval)
206 {
207 /* {
208 syscallarg(int) fd;
209 syscallarg(const netbsd32_voidp) buf;
210 syscallarg(netbsd32_size_t) nbyte;
211 } */
212 struct sys_write_args ua;
213
214 NETBSD32TO64_UAP(fd);
215 NETBSD32TOP_UAP(buf, void *);
216 NETBSD32TOX_UAP(nbyte, size_t);
217 return sys_write(l, &ua, retval);
218 }
219
220 int
221 netbsd32_close(struct lwp *l, const struct netbsd32_close_args *uap, register_t *retval)
222 {
223 /* {
224 syscallarg(int) fd;
225 } */
226 struct sys_close_args ua;
227
228 NETBSD32TO64_UAP(fd);
229 return sys_close(l, &ua, retval);
230 }
231
232 int
233 netbsd32_open(struct lwp *l, const struct netbsd32_open_args *uap, register_t *retval)
234 {
235 /* {
236 syscallarg(const netbsd32_charp) path;
237 syscallarg(int) flags;
238 syscallarg(mode_t) mode;
239 } */
240 struct sys_open_args ua;
241
242 NETBSD32TOP_UAP(path, const char);
243 NETBSD32TO64_UAP(flags);
244 NETBSD32TO64_UAP(mode);
245
246 return (sys_open(l, &ua, retval));
247 }
248
249 int
250 netbsd32_link(struct lwp *l, const struct netbsd32_link_args *uap, register_t *retval)
251 {
252 /* {
253 syscallarg(const netbsd32_charp) path;
254 syscallarg(const netbsd32_charp) link;
255 } */
256 struct sys_link_args ua;
257
258 NETBSD32TOP_UAP(path, const char);
259 NETBSD32TOP_UAP(link, const char);
260 return (sys_link(l, &ua, retval));
261 }
262
263 int
264 netbsd32_unlink(struct lwp *l, const struct netbsd32_unlink_args *uap, register_t *retval)
265 {
266 /* {
267 syscallarg(const netbsd32_charp) path;
268 } */
269 struct sys_unlink_args ua;
270
271 NETBSD32TOP_UAP(path, const char);
272
273 return (sys_unlink(l, &ua, retval));
274 }
275
276 int
277 netbsd32_chdir(struct lwp *l, const struct netbsd32_chdir_args *uap, register_t *retval)
278 {
279 /* {
280 syscallarg(const netbsd32_charp) path;
281 } */
282 struct sys_chdir_args ua;
283
284 NETBSD32TOP_UAP(path, const char);
285
286 return (sys_chdir(l, &ua, retval));
287 }
288
289 int
290 netbsd32_fchdir(struct lwp *l, const struct netbsd32_fchdir_args *uap, register_t *retval)
291 {
292 /* {
293 syscallarg(int) fd;
294 } */
295 struct sys_fchdir_args ua;
296
297 NETBSD32TO64_UAP(fd);
298
299 return (sys_fchdir(l, &ua, retval));
300 }
301
302 int
303 netbsd32___mknod50(struct lwp *l, const struct netbsd32___mknod50_args *uap, register_t *retval)
304 {
305 /* {
306 syscallarg(const netbsd32_charp) path;
307 syscallarg(mode_t) mode;
308 syscallarg(netbsd32_dev_t) dev;
309 } */
310
311 return do_sys_mknod(l, SCARG_P32(uap, path), SCARG(uap, mode),
312 SCARG(uap, dev), retval, UIO_USERSPACE);
313 }
314
315 int
316 netbsd32_chmod(struct lwp *l, const struct netbsd32_chmod_args *uap, register_t *retval)
317 {
318 /* {
319 syscallarg(const netbsd32_charp) path;
320 syscallarg(mode_t) mode;
321 } */
322 struct sys_chmod_args ua;
323
324 NETBSD32TOP_UAP(path, const char);
325 NETBSD32TO64_UAP(mode);
326
327 return (sys_chmod(l, &ua, retval));
328 }
329
330 int
331 netbsd32_chown(struct lwp *l, const struct netbsd32_chown_args *uap, register_t *retval)
332 {
333 /* {
334 syscallarg(const netbsd32_charp) path;
335 syscallarg(uid_t) uid;
336 syscallarg(gid_t) gid;
337 } */
338 struct sys_chown_args ua;
339
340 NETBSD32TOP_UAP(path, const char);
341 NETBSD32TO64_UAP(uid);
342 NETBSD32TO64_UAP(gid);
343
344 return (sys_chown(l, &ua, retval));
345 }
346
347 int
348 netbsd32_break(struct lwp *l, const struct netbsd32_break_args *uap, register_t *retval)
349 {
350 /* {
351 syscallarg(netbsd32_charp) nsize;
352 } */
353 struct sys_obreak_args ua;
354
355 NETBSD32TOP_UAP(nsize, char);
356 return (sys_obreak(l, &ua, retval));
357 }
358
359 int
360 netbsd32_mount(struct lwp *l, const struct netbsd32_mount_args *uap, register_t *retval)
361 {
362 #ifdef COMPAT_40
363 /* {
364 syscallarg(const netbsd32_charp) type;
365 syscallarg(const netbsd32_charp) path;
366 syscallarg(int) flags;
367 syscallarg(netbsd32_voidp) data;
368 } */
369 struct compat_40_sys_mount_args ua;
370
371 NETBSD32TOP_UAP(type, const char);
372 NETBSD32TOP_UAP(path, const char);
373 NETBSD32TO64_UAP(flags);
374 NETBSD32TOP_UAP(data, void);
375 return (compat_40_sys_mount(l, &ua, retval));
376 #else
377 return ENOSYS;
378 #endif
379 }
380
381 int
382 netbsd32_unmount(struct lwp *l, const struct netbsd32_unmount_args *uap, register_t *retval)
383 {
384 /* {
385 syscallarg(const netbsd32_charp) path;
386 syscallarg(int) flags;
387 } */
388 struct sys_unmount_args ua;
389
390 NETBSD32TOP_UAP(path, const char);
391 NETBSD32TO64_UAP(flags);
392 return (sys_unmount(l, &ua, retval));
393 }
394
395 int
396 netbsd32_setuid(struct lwp *l, const struct netbsd32_setuid_args *uap, register_t *retval)
397 {
398 /* {
399 syscallarg(uid_t) uid;
400 } */
401 struct sys_setuid_args ua;
402
403 NETBSD32TO64_UAP(uid);
404 return (sys_setuid(l, &ua, retval));
405 }
406
407 int
408 netbsd32_ptrace(struct lwp *l, const struct netbsd32_ptrace_args *uap, register_t *retval)
409 {
410 /* {
411 syscallarg(int) req;
412 syscallarg(pid_t) pid;
413 syscallarg(netbsd32_voidp) addr;
414 syscallarg(int) data;
415 } */
416 struct sys_ptrace_args ua;
417
418 NETBSD32TO64_UAP(req);
419 NETBSD32TO64_UAP(pid);
420 NETBSD32TOP_UAP(addr, void *);
421 NETBSD32TO64_UAP(data);
422
423 return (*sysent[SYS_ptrace].sy_call)(l, &ua, retval);
424 }
425
426 int
427 netbsd32_accept(struct lwp *l, const struct netbsd32_accept_args *uap, register_t *retval)
428 {
429 /* {
430 syscallarg(int) s;
431 syscallarg(netbsd32_sockaddrp_t) name;
432 syscallarg(netbsd32_intp) anamelen;
433 } */
434 struct sys_accept_args ua;
435
436 NETBSD32TO64_UAP(s);
437 NETBSD32TOP_UAP(name, struct sockaddr);
438 NETBSD32TOP_UAP(anamelen, socklen_t);
439 return (sys_accept(l, &ua, retval));
440 }
441
442 int
443 netbsd32_getpeername(struct lwp *l, const struct netbsd32_getpeername_args *uap, register_t *retval)
444 {
445 /* {
446 syscallarg(int) fdes;
447 syscallarg(netbsd32_sockaddrp_t) asa;
448 syscallarg(netbsd32_intp) alen;
449 } */
450 struct sys_getpeername_args ua;
451
452 NETBSD32TO64_UAP(fdes);
453 NETBSD32TOP_UAP(asa, struct sockaddr);
454 NETBSD32TOP_UAP(alen, socklen_t);
455 /* NB: do the protocol specific sockaddrs need to be converted? */
456 return (sys_getpeername(l, &ua, retval));
457 }
458
459 int
460 netbsd32_getsockname(struct lwp *l, const struct netbsd32_getsockname_args *uap, register_t *retval)
461 {
462 /* {
463 syscallarg(int) fdes;
464 syscallarg(netbsd32_sockaddrp_t) asa;
465 syscallarg(netbsd32_intp) alen;
466 } */
467 struct sys_getsockname_args ua;
468
469 NETBSD32TO64_UAP(fdes);
470 NETBSD32TOP_UAP(asa, struct sockaddr);
471 NETBSD32TOP_UAP(alen, socklen_t);
472 return (sys_getsockname(l, &ua, retval));
473 }
474
475 int
476 netbsd32_access(struct lwp *l, const struct netbsd32_access_args *uap, register_t *retval)
477 {
478 /* {
479 syscallarg(const netbsd32_charp) path;
480 syscallarg(int) flags;
481 } */
482 struct sys_access_args ua;
483
484 NETBSD32TOP_UAP(path, const char);
485 NETBSD32TO64_UAP(flags);
486
487 return sys_access(l, &ua, retval);
488 }
489
490 int
491 netbsd32_chflags(struct lwp *l, const struct netbsd32_chflags_args *uap, register_t *retval)
492 {
493 /* {
494 syscallarg(const netbsd32_charp) path;
495 syscallarg(netbsd32_u_long) flags;
496 } */
497 struct sys_chflags_args ua;
498
499 NETBSD32TOP_UAP(path, const char);
500 NETBSD32TO64_UAP(flags);
501
502 return (sys_chflags(l, &ua, retval));
503 }
504
505 int
506 netbsd32_fchflags(struct lwp *l, const struct netbsd32_fchflags_args *uap, register_t *retval)
507 {
508 /* {
509 syscallarg(int) fd;
510 syscallarg(netbsd32_u_long) flags;
511 } */
512 struct sys_fchflags_args ua;
513
514 NETBSD32TO64_UAP(fd);
515 NETBSD32TO64_UAP(flags);
516
517 return (sys_fchflags(l, &ua, retval));
518 }
519
520 int
521 netbsd32_lchflags(struct lwp *l, const struct netbsd32_lchflags_args *uap, register_t *retval)
522 {
523 /* {
524 syscallarg(const char *) path;
525 syscallarg(netbsd32_u_long) flags;
526 } */
527 struct sys_lchflags_args ua;
528
529 NETBSD32TOP_UAP(path, const char);
530 NETBSD32TO64_UAP(flags);
531
532 return (sys_lchflags(l, &ua, retval));
533 }
534
535 int
536 netbsd32_kill(struct lwp *l, const struct netbsd32_kill_args *uap, register_t *retval)
537 {
538 /* {
539 syscallarg(int) pid;
540 syscallarg(int) signum;
541 } */
542 struct sys_kill_args ua;
543
544 NETBSD32TO64_UAP(pid);
545 NETBSD32TO64_UAP(signum);
546
547 return (sys_kill(l, &ua, retval));
548 }
549
550 int
551 netbsd32_dup(struct lwp *l, const struct netbsd32_dup_args *uap, register_t *retval)
552 {
553 /* {
554 syscallarg(int) fd;
555 } */
556 struct sys_dup_args ua;
557
558 NETBSD32TO64_UAP(fd);
559
560 return (sys_dup(l, &ua, retval));
561 }
562
563 int
564 netbsd32_profil(struct lwp *l, const struct netbsd32_profil_args *uap, register_t *retval)
565 {
566 /* {
567 syscallarg(netbsd32_voidp) samples;
568 syscallarg(netbsd32_size_t) size;
569 syscallarg(netbsd32_u_long) offset;
570 syscallarg(u_int) scale;
571 } */
572 struct sys_profil_args ua;
573
574 NETBSD32TOP_UAP(samples, void *);
575 NETBSD32TOX_UAP(size, size_t);
576 NETBSD32TOX_UAP(offset, u_long);
577 NETBSD32TO64_UAP(scale);
578 return (sys_profil(l, &ua, retval));
579 }
580
581 int
582 netbsd32_ktrace(struct lwp *l, const struct netbsd32_ktrace_args *uap, register_t *retval)
583 {
584 /* {
585 syscallarg(const netbsd32_charp) fname;
586 syscallarg(int) ops;
587 syscallarg(int) facs;
588 syscallarg(int) pid;
589 } */
590 struct sys_ktrace_args ua;
591
592 NETBSD32TOP_UAP(fname, const char);
593 NETBSD32TO64_UAP(ops);
594 NETBSD32TO64_UAP(facs);
595 NETBSD32TO64_UAP(pid);
596 return (sys_ktrace(l, &ua, retval));
597 }
598
599 int
600 netbsd32_utrace(struct lwp *l, const struct netbsd32_utrace_args *uap, register_t *retval)
601 {
602 /* {
603 syscallarg(const netbsd32_charp) label;
604 syscallarg(netbsd32_voidp) addr;
605 syscallarg(netbsd32_size_t) len;
606 } */
607 struct sys_utrace_args ua;
608
609 NETBSD32TOP_UAP(label, const char);
610 NETBSD32TOP_UAP(addr, void);
611 NETBSD32TO64_UAP(len);
612 return (sys_utrace(l, &ua, retval));
613 }
614
615 int
616 netbsd32___getlogin(struct lwp *l, const struct netbsd32___getlogin_args *uap, register_t *retval)
617 {
618 /* {
619 syscallarg(netbsd32_charp) namebuf;
620 syscallarg(u_int) namelen;
621 } */
622 struct sys___getlogin_args ua;
623
624 NETBSD32TOP_UAP(namebuf, char);
625 NETBSD32TO64_UAP(namelen);
626 return (sys___getlogin(l, &ua, retval));
627 }
628
629 int
630 netbsd32_setlogin(struct lwp *l, const struct netbsd32_setlogin_args *uap, register_t *retval)
631 {
632 /* {
633 syscallarg(const netbsd32_charp) namebuf;
634 } */
635 struct sys___setlogin_args ua;
636
637 NETBSD32TOP_UAP(namebuf, char);
638 return (sys___setlogin(l, &ua, retval));
639 }
640
641 int
642 netbsd32_acct(struct lwp *l, const struct netbsd32_acct_args *uap, register_t *retval)
643 {
644 /* {
645 syscallarg(const netbsd32_charp) path;
646 } */
647 struct sys_acct_args ua;
648
649 NETBSD32TOP_UAP(path, const char);
650 return (sys_acct(l, &ua, retval));
651 }
652
653 int
654 netbsd32_revoke(struct lwp *l, const struct netbsd32_revoke_args *uap, register_t *retval)
655 {
656 /* {
657 syscallarg(const netbsd32_charp) path;
658 } */
659 struct sys_revoke_args ua;
660
661 NETBSD32TOP_UAP(path, const char);
662
663 return (sys_revoke(l, &ua, retval));
664 }
665
666 int
667 netbsd32_symlink(struct lwp *l, const struct netbsd32_symlink_args *uap, register_t *retval)
668 {
669 /* {
670 syscallarg(const netbsd32_charp) path;
671 syscallarg(const netbsd32_charp) link;
672 } */
673 struct sys_symlink_args ua;
674
675 NETBSD32TOP_UAP(path, const char);
676 NETBSD32TOP_UAP(link, const char);
677
678 return (sys_symlink(l, &ua, retval));
679 }
680
681 int
682 netbsd32_readlink(struct lwp *l, const struct netbsd32_readlink_args *uap, register_t *retval)
683 {
684 /* {
685 syscallarg(const netbsd32_charp) path;
686 syscallarg(netbsd32_charp) buf;
687 syscallarg(netbsd32_size_t) count;
688 } */
689 struct sys_readlink_args ua;
690
691 NETBSD32TOP_UAP(path, const char);
692 NETBSD32TOP_UAP(buf, char);
693 NETBSD32TOX_UAP(count, size_t);
694
695 return (sys_readlink(l, &ua, retval));
696 }
697
698 int
699 netbsd32_umask(struct lwp *l, const struct netbsd32_umask_args *uap, register_t *retval)
700 {
701 /* {
702 syscallarg(mode_t) newmask;
703 } */
704 struct sys_umask_args ua;
705
706 NETBSD32TO64_UAP(newmask);
707 return (sys_umask(l, &ua, retval));
708 }
709
710 int
711 netbsd32_chroot(struct lwp *l, const struct netbsd32_chroot_args *uap, register_t *retval)
712 {
713 /* {
714 syscallarg(const netbsd32_charp) path;
715 } */
716 struct sys_chroot_args ua;
717
718 NETBSD32TOP_UAP(path, const char);
719 return (sys_chroot(l, &ua, retval));
720 }
721
722 int
723 netbsd32_sbrk(struct lwp *l, const struct netbsd32_sbrk_args *uap, register_t *retval)
724 {
725 /* {
726 syscallarg(int) incr;
727 } */
728 struct sys_sbrk_args ua;
729
730 NETBSD32TO64_UAP(incr);
731 return (sys_sbrk(l, &ua, retval));
732 }
733
734 int
735 netbsd32_sstk(struct lwp *l, const struct netbsd32_sstk_args *uap, register_t *retval)
736 {
737 /* {
738 syscallarg(int) incr;
739 } */
740 struct sys_sstk_args ua;
741
742 NETBSD32TO64_UAP(incr);
743 return (sys_sstk(l, &ua, retval));
744 }
745
746 int
747 netbsd32_munmap(struct lwp *l, const struct netbsd32_munmap_args *uap, register_t *retval)
748 {
749 /* {
750 syscallarg(netbsd32_voidp) addr;
751 syscallarg(netbsd32_size_t) len;
752 } */
753 struct sys_munmap_args ua;
754
755 NETBSD32TOP_UAP(addr, void);
756 NETBSD32TOX_UAP(len, size_t);
757 return (sys_munmap(l, &ua, retval));
758 }
759
760 int
761 netbsd32_mprotect(struct lwp *l, const struct netbsd32_mprotect_args *uap, register_t *retval)
762 {
763 /* {
764 syscallarg(netbsd32_voidp) addr;
765 syscallarg(netbsd32_size_t) len;
766 syscallarg(int) prot;
767 } */
768 struct sys_mprotect_args ua;
769
770 NETBSD32TOP_UAP(addr, void);
771 NETBSD32TOX_UAP(len, size_t);
772 NETBSD32TO64_UAP(prot);
773 return (sys_mprotect(l, &ua, retval));
774 }
775
776 int
777 netbsd32_madvise(struct lwp *l, const struct netbsd32_madvise_args *uap, register_t *retval)
778 {
779 /* {
780 syscallarg(netbsd32_voidp) addr;
781 syscallarg(netbsd32_size_t) len;
782 syscallarg(int) behav;
783 } */
784 struct sys_madvise_args ua;
785
786 NETBSD32TOP_UAP(addr, void);
787 NETBSD32TOX_UAP(len, size_t);
788 NETBSD32TO64_UAP(behav);
789 return (sys_madvise(l, &ua, retval));
790 }
791
792 int
793 netbsd32_mincore(struct lwp *l, const struct netbsd32_mincore_args *uap, register_t *retval)
794 {
795 /* {
796 syscallarg(netbsd32_voidp) addr;
797 syscallarg(netbsd32_size_t) len;
798 syscallarg(netbsd32_charp) vec;
799 } */
800 struct sys_mincore_args ua;
801
802 NETBSD32TOP_UAP(addr, void *);
803 NETBSD32TOX_UAP(len, size_t);
804 NETBSD32TOP_UAP(vec, char);
805 return (sys_mincore(l, &ua, retval));
806 }
807
808 /* XXX MOVE ME XXX ? */
809 int
810 netbsd32_getgroups(struct lwp *l, const struct netbsd32_getgroups_args *uap, register_t *retval)
811 {
812 /* {
813 syscallarg(int) gidsetsize;
814 syscallarg(netbsd32_gid_tp) gidset;
815 } */
816 struct sys_getgroups_args ua;
817
818 /* Since sizeof (gid_t) == sizeof (netbsd32_gid_t) ... */
819
820 NETBSD32TO64_UAP(gidsetsize);
821 NETBSD32TOP_UAP(gidset, gid_t);
822 return (sys_getgroups(l, &ua, retval));
823 }
824
825 int
826 netbsd32_setgroups(struct lwp *l, const struct netbsd32_setgroups_args *uap, register_t *retval)
827 {
828 /* {
829 syscallarg(int) gidsetsize;
830 syscallarg(const netbsd32_gid_tp) gidset;
831 } */
832 struct sys_setgroups_args ua;
833
834 NETBSD32TO64_UAP(gidsetsize);
835 NETBSD32TOP_UAP(gidset, gid_t);
836 return (sys_setgroups(l, &ua, retval));
837 }
838
839 int
840 netbsd32_setpgid(struct lwp *l, const struct netbsd32_setpgid_args *uap, register_t *retval)
841 {
842 /* {
843 syscallarg(int) pid;
844 syscallarg(int) pgid;
845 } */
846 struct sys_setpgid_args ua;
847
848 NETBSD32TO64_UAP(pid);
849 NETBSD32TO64_UAP(pgid);
850 return (sys_setpgid(l, &ua, retval));
851 }
852
853 int
854 netbsd32_fcntl(struct lwp *l, const struct netbsd32_fcntl_args *uap, register_t *retval)
855 {
856 /* {
857 syscallarg(int) fd;
858 syscallarg(int) cmd;
859 syscallarg(netbsd32_voidp) arg;
860 } */
861 struct sys_fcntl_args ua;
862
863 NETBSD32TO64_UAP(fd);
864 NETBSD32TO64_UAP(cmd);
865 NETBSD32TOP_UAP(arg, void);
866 /* we can do this because `struct flock' doesn't change */
867 return (sys_fcntl(l, &ua, retval));
868 }
869
870 int
871 netbsd32_dup2(struct lwp *l, const struct netbsd32_dup2_args *uap, register_t *retval)
872 {
873 /* {
874 syscallarg(int) from;
875 syscallarg(int) to;
876 } */
877 struct sys_dup2_args ua;
878
879 NETBSD32TO64_UAP(from);
880 NETBSD32TO64_UAP(to);
881 return (sys_dup2(l, &ua, retval));
882 }
883
884 int
885 netbsd32_fsync(struct lwp *l, const struct netbsd32_fsync_args *uap, register_t *retval)
886 {
887 /* {
888 syscallarg(int) fd;
889 } */
890 struct sys_fsync_args ua;
891
892 NETBSD32TO64_UAP(fd);
893 return (sys_fsync(l, &ua, retval));
894 }
895
896 int
897 netbsd32_setpriority(struct lwp *l, const struct netbsd32_setpriority_args *uap, register_t *retval)
898 {
899 /* {
900 syscallarg(int) which;
901 syscallarg(int) who;
902 syscallarg(int) prio;
903 } */
904 struct sys_setpriority_args ua;
905
906 NETBSD32TO64_UAP(which);
907 NETBSD32TO64_UAP(who);
908 NETBSD32TO64_UAP(prio);
909 return (sys_setpriority(l, &ua, retval));
910 }
911
912 int
913 netbsd32___socket30(struct lwp *l, const struct netbsd32___socket30_args *uap, register_t *retval)
914 {
915 /* {
916 syscallarg(int) domain;
917 syscallarg(int) type;
918 syscallarg(int) protocol;
919 } */
920 struct sys___socket30_args ua;
921
922 NETBSD32TO64_UAP(domain);
923 NETBSD32TO64_UAP(type);
924 NETBSD32TO64_UAP(protocol);
925 return (sys___socket30(l, &ua, retval));
926 }
927
928 int
929 netbsd32_connect(struct lwp *l, const struct netbsd32_connect_args *uap, register_t *retval)
930 {
931 /* {
932 syscallarg(int) s;
933 syscallarg(const netbsd32_sockaddrp_t) name;
934 syscallarg(int) namelen;
935 } */
936 struct sys_connect_args ua;
937
938 NETBSD32TO64_UAP(s);
939 NETBSD32TOP_UAP(name, struct sockaddr);
940 NETBSD32TO64_UAP(namelen);
941 return (sys_connect(l, &ua, retval));
942 }
943
944 int
945 netbsd32_getpriority(struct lwp *l, const struct netbsd32_getpriority_args *uap, register_t *retval)
946 {
947 /* {
948 syscallarg(int) which;
949 syscallarg(int) who;
950 } */
951 struct sys_getpriority_args ua;
952
953 NETBSD32TO64_UAP(which);
954 NETBSD32TO64_UAP(who);
955 return (sys_getpriority(l, &ua, retval));
956 }
957
958 int
959 netbsd32_bind(struct lwp *l, const struct netbsd32_bind_args *uap, register_t *retval)
960 {
961 /* {
962 syscallarg(int) s;
963 syscallarg(const netbsd32_sockaddrp_t) name;
964 syscallarg(int) namelen;
965 } */
966 struct sys_bind_args ua;
967
968 NETBSD32TO64_UAP(s);
969 NETBSD32TOP_UAP(name, struct sockaddr);
970 NETBSD32TO64_UAP(namelen);
971 return (sys_bind(l, &ua, retval));
972 }
973
974 int
975 netbsd32_setsockopt(struct lwp *l, const struct netbsd32_setsockopt_args *uap, register_t *retval)
976 {
977 /* {
978 syscallarg(int) s;
979 syscallarg(int) level;
980 syscallarg(int) name;
981 syscallarg(const netbsd32_voidp) val;
982 syscallarg(int) valsize;
983 } */
984 struct sys_setsockopt_args ua;
985
986 NETBSD32TO64_UAP(s);
987 NETBSD32TO64_UAP(level);
988 NETBSD32TO64_UAP(name);
989 NETBSD32TOP_UAP(val, void);
990 NETBSD32TO64_UAP(valsize);
991 /* may be more efficient to do this inline. */
992 return (sys_setsockopt(l, &ua, retval));
993 }
994
995 int
996 netbsd32_listen(struct lwp *l, const struct netbsd32_listen_args *uap, register_t *retval)
997 {
998 /* {
999 syscallarg(int) s;
1000 syscallarg(int) backlog;
1001 } */
1002 struct sys_listen_args ua;
1003
1004 NETBSD32TO64_UAP(s);
1005 NETBSD32TO64_UAP(backlog);
1006 return (sys_listen(l, &ua, retval));
1007 }
1008
1009 int
1010 netbsd32_fchown(struct lwp *l, const struct netbsd32_fchown_args *uap, register_t *retval)
1011 {
1012 /* {
1013 syscallarg(int) fd;
1014 syscallarg(uid_t) uid;
1015 syscallarg(gid_t) gid;
1016 } */
1017 struct sys_fchown_args ua;
1018
1019 NETBSD32TO64_UAP(fd);
1020 NETBSD32TO64_UAP(uid);
1021 NETBSD32TO64_UAP(gid);
1022 return (sys_fchown(l, &ua, retval));
1023 }
1024
1025 int
1026 netbsd32_fchmod(struct lwp *l, const struct netbsd32_fchmod_args *uap, register_t *retval)
1027 {
1028 /* {
1029 syscallarg(int) fd;
1030 syscallarg(mode_t) mode;
1031 } */
1032 struct sys_fchmod_args ua;
1033
1034 NETBSD32TO64_UAP(fd);
1035 NETBSD32TO64_UAP(mode);
1036 return (sys_fchmod(l, &ua, retval));
1037 }
1038
1039 int
1040 netbsd32_setreuid(struct lwp *l, const struct netbsd32_setreuid_args *uap, register_t *retval)
1041 {
1042 /* {
1043 syscallarg(uid_t) ruid;
1044 syscallarg(uid_t) euid;
1045 } */
1046 struct sys_setreuid_args ua;
1047
1048 NETBSD32TO64_UAP(ruid);
1049 NETBSD32TO64_UAP(euid);
1050 return (sys_setreuid(l, &ua, retval));
1051 }
1052
1053 int
1054 netbsd32_setregid(struct lwp *l, const struct netbsd32_setregid_args *uap, register_t *retval)
1055 {
1056 /* {
1057 syscallarg(gid_t) rgid;
1058 syscallarg(gid_t) egid;
1059 } */
1060 struct sys_setregid_args ua;
1061
1062 NETBSD32TO64_UAP(rgid);
1063 NETBSD32TO64_UAP(egid);
1064 return (sys_setregid(l, &ua, retval));
1065 }
1066
1067 int
1068 netbsd32_getsockopt(struct lwp *l, const struct netbsd32_getsockopt_args *uap, register_t *retval)
1069 {
1070 /* {
1071 syscallarg(int) s;
1072 syscallarg(int) level;
1073 syscallarg(int) name;
1074 syscallarg(netbsd32_voidp) val;
1075 syscallarg(netbsd32_intp) avalsize;
1076 } */
1077 struct sys_getsockopt_args ua;
1078
1079 NETBSD32TO64_UAP(s);
1080 NETBSD32TO64_UAP(level);
1081 NETBSD32TO64_UAP(name);
1082 NETBSD32TOP_UAP(val, void);
1083 NETBSD32TOP_UAP(avalsize, socklen_t);
1084 return (sys_getsockopt(l, &ua, retval));
1085 }
1086
1087 int
1088 netbsd32_rename(struct lwp *l, const struct netbsd32_rename_args *uap, register_t *retval)
1089 {
1090 /* {
1091 syscallarg(const netbsd32_charp) from;
1092 syscallarg(const netbsd32_charp) to;
1093 } */
1094 struct sys_rename_args ua;
1095
1096 NETBSD32TOP_UAP(from, const char);
1097 NETBSD32TOP_UAP(to, const char);
1098
1099 return (sys_rename(l, &ua, retval));
1100 }
1101
1102 int
1103 netbsd32_flock(struct lwp *l, const struct netbsd32_flock_args *uap, register_t *retval)
1104 {
1105 /* {
1106 syscallarg(int) fd;
1107 syscallarg(int) how;
1108 } */
1109 struct sys_flock_args ua;
1110
1111 NETBSD32TO64_UAP(fd);
1112 NETBSD32TO64_UAP(how);
1113
1114 return (sys_flock(l, &ua, retval));
1115 }
1116
1117 int
1118 netbsd32_mkfifo(struct lwp *l, const struct netbsd32_mkfifo_args *uap, register_t *retval)
1119 {
1120 /* {
1121 syscallarg(const netbsd32_charp) path;
1122 syscallarg(mode_t) mode;
1123 } */
1124 struct sys_mkfifo_args ua;
1125
1126 NETBSD32TOP_UAP(path, const char);
1127 NETBSD32TO64_UAP(mode);
1128 return (sys_mkfifo(l, &ua, retval));
1129 }
1130
1131 int
1132 netbsd32_shutdown(struct lwp *l, const struct netbsd32_shutdown_args *uap, register_t *retval)
1133 {
1134 /* {
1135 syscallarg(int) s;
1136 syscallarg(int) how;
1137 } */
1138 struct sys_shutdown_args ua;
1139
1140 NETBSD32TO64_UAP(s);
1141 NETBSD32TO64_UAP(how);
1142 return (sys_shutdown(l, &ua, retval));
1143 }
1144
1145 int
1146 netbsd32_socketpair(struct lwp *l, const struct netbsd32_socketpair_args *uap, register_t *retval)
1147 {
1148 /* {
1149 syscallarg(int) domain;
1150 syscallarg(int) type;
1151 syscallarg(int) protocol;
1152 syscallarg(netbsd32_intp) rsv;
1153 } */
1154 struct sys_socketpair_args ua;
1155
1156 NETBSD32TO64_UAP(domain);
1157 NETBSD32TO64_UAP(type);
1158 NETBSD32TO64_UAP(protocol);
1159 NETBSD32TOP_UAP(rsv, int);
1160 /* Since we're just copying out two `int's we can do this */
1161 return (sys_socketpair(l, &ua, retval));
1162 }
1163
1164 int
1165 netbsd32_mkdir(struct lwp *l, const struct netbsd32_mkdir_args *uap, register_t *retval)
1166 {
1167 /* {
1168 syscallarg(const netbsd32_charp) path;
1169 syscallarg(mode_t) mode;
1170 } */
1171 struct sys_mkdir_args ua;
1172
1173 NETBSD32TOP_UAP(path, const char);
1174 NETBSD32TO64_UAP(mode);
1175 return (sys_mkdir(l, &ua, retval));
1176 }
1177
1178 int
1179 netbsd32_rmdir(struct lwp *l, const struct netbsd32_rmdir_args *uap, register_t *retval)
1180 {
1181 /* {
1182 syscallarg(const netbsd32_charp) path;
1183 } */
1184 struct sys_rmdir_args ua;
1185
1186 NETBSD32TOP_UAP(path, const char);
1187 return (sys_rmdir(l, &ua, retval));
1188 }
1189
1190 int
1191 netbsd32_quotactl(struct lwp *l, const struct netbsd32_quotactl_args *uap, register_t *retval)
1192 {
1193 /* {
1194 syscallarg(const netbsd32_charp) path;
1195 syscallarg(int) cmd;
1196 syscallarg(int) uid;
1197 syscallarg(netbsd32_voidp) arg;
1198 } */
1199 struct sys_quotactl_args ua;
1200
1201 NETBSD32TOP_UAP(path, const char);
1202 NETBSD32TO64_UAP(cmd);
1203 NETBSD32TO64_UAP(uid);
1204 NETBSD32TOP_UAP(arg, void *);
1205 return (sys_quotactl(l, &ua, retval));
1206 }
1207
1208 int
1209 netbsd32_nfssvc(struct lwp *l, const struct netbsd32_nfssvc_args *uap, register_t *retval)
1210 {
1211 #if 0
1212 /* {
1213 syscallarg(int) flag;
1214 syscallarg(netbsd32_voidp) argp;
1215 } */
1216 struct sys_nfssvc_args ua;
1217
1218 NETBSD32TO64_UAP(flag);
1219 NETBSD32TOP_UAP(argp, void);
1220 return (sys_nfssvc(l, &ua, retval));
1221 #else
1222 /* Why would we want to support a 32-bit nfsd? */
1223 return (ENOSYS);
1224 #endif
1225 }
1226
1227 int
1228 netbsd32___getfh30(struct lwp *l, const struct netbsd32___getfh30_args *uap, register_t *retval)
1229 {
1230 /* {
1231 syscallarg(const netbsd32_charp) fname;
1232 syscallarg(netbsd32_fhandlep_t) fhp;
1233 syscallarg(netbsd32_size_tp) fh_size;
1234 } */
1235 struct vnode *vp;
1236 fhandle_t *fh;
1237 int error;
1238 struct nameidata nd;
1239 netbsd32_size_t sz32;
1240 size_t sz;
1241
1242 /*
1243 * Must be super user
1244 */
1245 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FILEHANDLE,
1246 0, NULL, NULL, NULL);
1247 if (error)
1248 return (error);
1249 fh = NULL;
1250 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, UIO_USERSPACE,
1251 SCARG_P32(uap, fname));
1252 error = namei(&nd);
1253 if (error)
1254 return (error);
1255 vp = nd.ni_vp;
1256 error = copyin(SCARG_P32(uap, fh_size), &sz32,
1257 sizeof(netbsd32_size_t));
1258 if (!error) {
1259 fh = malloc(sz32, M_TEMP, M_WAITOK);
1260 if (fh == NULL)
1261 return EINVAL;
1262 sz = sz32;
1263 error = vfs_composefh(vp, fh, &sz);
1264 sz32 = sz;
1265 }
1266 vput(vp);
1267 if (error == E2BIG)
1268 copyout(&sz, SCARG_P32(uap, fh_size), sizeof(size_t));
1269 if (error == 0) {
1270 error = copyout(&sz32, SCARG_P32(uap, fh_size),
1271 sizeof(netbsd32_size_t));
1272 if (!error)
1273 error = copyout(fh, SCARG_P32(uap, fhp), sz);
1274 }
1275 free(fh, M_TEMP);
1276 return (error);
1277 }
1278
1279 int
1280 netbsd32_pread(struct lwp *l, const struct netbsd32_pread_args *uap, register_t *retval)
1281 {
1282 /* {
1283 syscallarg(int) fd;
1284 syscallarg(netbsd32_voidp) buf;
1285 syscallarg(netbsd32_size_t) nbyte;
1286 syscallarg(int) PAD;
1287 syscallarg(off_t) offset;
1288 } */
1289 struct sys_pread_args ua;
1290
1291 NETBSD32TO64_UAP(fd);
1292 NETBSD32TOP_UAP(buf, void);
1293 NETBSD32TOX_UAP(nbyte, size_t);
1294 NETBSD32TO64_UAP(PAD);
1295 NETBSD32TO64_UAP(offset);
1296 return sys_pread(l, &ua, retval);
1297 }
1298
1299 int
1300 netbsd32_pwrite(struct lwp *l, const struct netbsd32_pwrite_args *uap, register_t *retval)
1301 {
1302 /* {
1303 syscallarg(int) fd;
1304 syscallarg(const netbsd32_voidp) buf;
1305 syscallarg(netbsd32_size_t) nbyte;
1306 syscallarg(int) PAD;
1307 syscallarg(off_t) offset;
1308 } */
1309 struct sys_pwrite_args ua;
1310
1311 NETBSD32TO64_UAP(fd);
1312 NETBSD32TOP_UAP(buf, void);
1313 NETBSD32TOX_UAP(nbyte, size_t);
1314 NETBSD32TO64_UAP(PAD);
1315 NETBSD32TO64_UAP(offset);
1316 return sys_pwrite(l, &ua, retval);
1317 }
1318
1319 int
1320 netbsd32_setgid(struct lwp *l, const struct netbsd32_setgid_args *uap, register_t *retval)
1321 {
1322 /* {
1323 syscallarg(gid_t) gid;
1324 } */
1325 struct sys_setgid_args ua;
1326
1327 NETBSD32TO64_UAP(gid);
1328 return (sys_setgid(l, &ua, retval));
1329 }
1330
1331 int
1332 netbsd32_setegid(struct lwp *l, const struct netbsd32_setegid_args *uap, register_t *retval)
1333 {
1334 /* {
1335 syscallarg(gid_t) egid;
1336 } */
1337 struct sys_setegid_args ua;
1338
1339 NETBSD32TO64_UAP(egid);
1340 return (sys_setegid(l, &ua, retval));
1341 }
1342
1343 int
1344 netbsd32_seteuid(struct lwp *l, const struct netbsd32_seteuid_args *uap, register_t *retval)
1345 {
1346 /* {
1347 syscallarg(gid_t) euid;
1348 } */
1349 struct sys_seteuid_args ua;
1350
1351 NETBSD32TO64_UAP(euid);
1352 return (sys_seteuid(l, &ua, retval));
1353 }
1354
1355 #ifdef LFS
1356 int
1357 netbsd32_lfs_bmapv(struct lwp *l, const struct netbsd32_lfs_bmapv_args *v, register_t *retval)
1358 {
1359
1360 return (ENOSYS); /* XXX */
1361 }
1362
1363 int
1364 netbsd32_lfs_markv(struct lwp *l, const struct netbsd32_lfs_markv_args *v, register_t *retval)
1365 {
1366
1367 return (ENOSYS); /* XXX */
1368 }
1369
1370 int
1371 netbsd32_lfs_segclean(struct lwp *l, const struct netbsd32_lfs_segclean_args *v, register_t *retval)
1372 {
1373
1374 return (ENOSYS); /* XXX */
1375 }
1376
1377 int
1378 netbsd32___lfs_segwait50(struct lwp *l, const struct netbsd32___lfs_segwait50_args *v, register_t *retval)
1379 {
1380
1381 return (ENOSYS); /* XXX */
1382 }
1383 #endif
1384
1385 int
1386 netbsd32_pathconf(struct lwp *l, const struct netbsd32_pathconf_args *uap, register_t *retval)
1387 {
1388 /* {
1389 syscallarg(int) fd;
1390 syscallarg(int) name;
1391 } */
1392 struct sys_pathconf_args ua;
1393
1394 NETBSD32TOP_UAP(path, const char);
1395 NETBSD32TO64_UAP(name);
1396 return sys_pathconf(l, &ua, retval);
1397 }
1398
1399 int
1400 netbsd32_fpathconf(struct lwp *l, const struct netbsd32_fpathconf_args *uap, register_t *retval)
1401 {
1402 /* {
1403 syscallarg(int) fd;
1404 syscallarg(int) name;
1405 } */
1406 struct sys_fpathconf_args ua;
1407
1408 NETBSD32TO64_UAP(fd);
1409 NETBSD32TO64_UAP(name);
1410 return sys_fpathconf(l, &ua, retval);
1411 }
1412
1413 int
1414 netbsd32_getrlimit(struct lwp *l, const struct netbsd32_getrlimit_args *uap, register_t *retval)
1415 {
1416 /* {
1417 syscallarg(int) which;
1418 syscallarg(netbsd32_rlimitp_t) rlp;
1419 } */
1420 int which = SCARG(uap, which);
1421
1422 if ((u_int)which >= RLIM_NLIMITS)
1423 return (EINVAL);
1424 return (copyout(&l->l_proc->p_rlimit[which],
1425 SCARG_P32(uap, rlp), sizeof(struct rlimit)));
1426 }
1427
1428 int
1429 netbsd32_setrlimit(struct lwp *l, const struct netbsd32_setrlimit_args *uap, register_t *retval)
1430 {
1431 /* {
1432 syscallarg(int) which;
1433 syscallarg(const netbsd32_rlimitp_t) rlp;
1434 } */
1435 int which = SCARG(uap, which);
1436 struct rlimit alim;
1437 int error;
1438
1439 error = copyin(SCARG_P32(uap, rlp), &alim, sizeof(struct rlimit));
1440 if (error)
1441 return (error);
1442
1443 switch (which) {
1444 case RLIMIT_DATA:
1445 if (LIMITCHECK(alim.rlim_cur, MAXDSIZ32))
1446 alim.rlim_cur = MAXDSIZ32;
1447 if (LIMITCHECK(alim.rlim_max, MAXDSIZ32))
1448 alim.rlim_max = MAXDSIZ32;
1449 break;
1450
1451 case RLIMIT_STACK:
1452 if (LIMITCHECK(alim.rlim_cur, MAXSSIZ32))
1453 alim.rlim_cur = MAXSSIZ32;
1454 if (LIMITCHECK(alim.rlim_max, MAXSSIZ32))
1455 alim.rlim_max = MAXSSIZ32;
1456 default:
1457 break;
1458 }
1459
1460 return (dosetrlimit(l, l->l_proc, which, &alim));
1461 }
1462
1463 int
1464 netbsd32_mmap(struct lwp *l, const struct netbsd32_mmap_args *uap, register_t *retval)
1465 {
1466 /* {
1467 syscallarg(netbsd32_voidp) addr;
1468 syscallarg(netbsd32_size_t) len;
1469 syscallarg(int) prot;
1470 syscallarg(int) flags;
1471 syscallarg(int) fd;
1472 syscallarg(netbsd32_long) PAD;
1473 syscallarg(off_t) pos;
1474 } */
1475 struct sys_mmap_args ua;
1476 int error;
1477
1478 NETBSD32TOP_UAP(addr, void);
1479 NETBSD32TOX_UAP(len, size_t);
1480 NETBSD32TO64_UAP(prot);
1481 NETBSD32TO64_UAP(flags);
1482 NETBSD32TO64_UAP(fd);
1483 NETBSD32TOX_UAP(PAD, long);
1484 NETBSD32TOX_UAP(pos, off_t);
1485 error = sys_mmap(l, &ua, retval);
1486 if ((u_long)*retval > (u_long)UINT_MAX) {
1487 printf("netbsd32_mmap: retval out of range: 0x%lx",
1488 (u_long)*retval);
1489 /* Should try to recover and return an error here. */
1490 }
1491 return (error);
1492 }
1493
1494 int
1495 netbsd32_mremap(struct lwp *l, const struct netbsd32_mremap_args *uap, register_t *retval)
1496 {
1497 /* {
1498 syscallarg(void *) old_address;
1499 syscallarg(size_t) old_size;
1500 syscallarg(void *) new_address;
1501 syscallarg(size_t) new_size;
1502 syscallarg(int) flags;
1503 } */
1504 struct sys_mremap_args ua;
1505
1506 NETBSD32TOP_UAP(old_address, void);
1507 NETBSD32TOX_UAP(old_size, size_t);
1508 NETBSD32TOP_UAP(new_address, void);
1509 NETBSD32TOX_UAP(new_size, size_t);
1510 NETBSD32TO64_UAP(flags);
1511
1512 return sys_mremap(l, &ua, retval);
1513 }
1514
1515 int
1516 netbsd32_lseek(struct lwp *l, const struct netbsd32_lseek_args *uap, register_t *retval)
1517 {
1518 /* {
1519 syscallarg(int) fd;
1520 syscallarg(int) PAD;
1521 syscallarg(off_t) offset;
1522 syscallarg(int) whence;
1523 } */
1524 struct sys_lseek_args ua;
1525 union {
1526 register_t retval64[2];
1527 register32_t retval32[4];
1528 } newpos;
1529 int rv;
1530
1531 NETBSD32TO64_UAP(fd);
1532 NETBSD32TO64_UAP(PAD);
1533 NETBSD32TO64_UAP(offset);
1534 NETBSD32TO64_UAP(whence);
1535 rv = sys_lseek(l, &ua, newpos.retval64);
1536
1537 /*
1538 * We have to split the 64 bit value into 2 halves which will
1539 * end up in separate 32 bit registers.
1540 * This should DTRT on big and little-endian systems provided that
1541 * gcc's 'strict aliasing' tests don't decide that the retval32[]
1542 * entries can't have been assigned to, so need not be read!
1543 */
1544 retval[0] = newpos.retval32[0];
1545 retval[1] = newpos.retval32[1];
1546
1547 return rv;
1548 }
1549
1550 int
1551 netbsd32_truncate(struct lwp *l, const struct netbsd32_truncate_args *uap, register_t *retval)
1552 {
1553 /* {
1554 syscallarg(const netbsd32_charp) path;
1555 syscallarg(int) PAD;
1556 syscallarg(off_t) length;
1557 } */
1558 struct sys_truncate_args ua;
1559
1560 NETBSD32TOP_UAP(path, const char);
1561 NETBSD32TO64_UAP(PAD);
1562 NETBSD32TO64_UAP(length);
1563 return (sys_truncate(l, &ua, retval));
1564 }
1565
1566 int
1567 netbsd32_ftruncate(struct lwp *l, const struct netbsd32_ftruncate_args *uap, register_t *retval)
1568 {
1569 /* {
1570 syscallarg(int) fd;
1571 syscallarg(int) PAD;
1572 syscallarg(off_t) length;
1573 } */
1574 struct sys_ftruncate_args ua;
1575
1576 NETBSD32TO64_UAP(fd);
1577 NETBSD32TO64_UAP(PAD);
1578 NETBSD32TO64_UAP(length);
1579 return (sys_ftruncate(l, &ua, retval));
1580 }
1581
1582 int
1583 netbsd32_mlock(struct lwp *l, const struct netbsd32_mlock_args *uap, register_t *retval)
1584 {
1585 /* {
1586 syscallarg(const netbsd32_voidp) addr;
1587 syscallarg(netbsd32_size_t) len;
1588 } */
1589 struct sys_mlock_args ua;
1590
1591 NETBSD32TOP_UAP(addr, const void);
1592 NETBSD32TO64_UAP(len);
1593 return (sys_mlock(l, &ua, retval));
1594 }
1595
1596 int
1597 netbsd32_munlock(struct lwp *l, const struct netbsd32_munlock_args *uap, register_t *retval)
1598 {
1599 /* {
1600 syscallarg(const netbsd32_voidp) addr;
1601 syscallarg(netbsd32_size_t) len;
1602 } */
1603 struct sys_munlock_args ua;
1604
1605 NETBSD32TOP_UAP(addr, const void);
1606 NETBSD32TO64_UAP(len);
1607 return (sys_munlock(l, &ua, retval));
1608 }
1609
1610 int
1611 netbsd32_undelete(struct lwp *l, const struct netbsd32_undelete_args *uap, register_t *retval)
1612 {
1613 /* {
1614 syscallarg(const netbsd32_charp) path;
1615 } */
1616 struct sys_undelete_args ua;
1617
1618 NETBSD32TOP_UAP(path, const char);
1619 return (sys_undelete(l, &ua, retval));
1620 }
1621
1622 int
1623 netbsd32_getpgid(struct lwp *l, const struct netbsd32_getpgid_args *uap, register_t *retval)
1624 {
1625 /* {
1626 syscallarg(pid_t) pid;
1627 } */
1628 struct sys_getpgid_args ua;
1629
1630 NETBSD32TO64_UAP(pid);
1631 return (sys_getpgid(l, &ua, retval));
1632 }
1633
1634 int
1635 netbsd32_reboot(struct lwp *l, const struct netbsd32_reboot_args *uap, register_t *retval)
1636 {
1637 /* {
1638 syscallarg(int) opt;
1639 syscallarg(netbsd32_charp) bootstr;
1640 } */
1641 struct sys_reboot_args ua;
1642
1643 NETBSD32TO64_UAP(opt);
1644 NETBSD32TOP_UAP(bootstr, char);
1645 return (sys_reboot(l, &ua, retval));
1646 }
1647
1648 #include <sys/poll.h>
1649 int
1650 netbsd32_poll(struct lwp *l, const struct netbsd32_poll_args *uap, register_t *retval)
1651 {
1652 /* {
1653 syscallarg(netbsd32_pollfdp_t) fds;
1654 syscallarg(u_int) nfds;
1655 syscallarg(int) timeout;
1656 } */
1657 struct sys_poll_args ua;
1658
1659 NETBSD32TOP_UAP(fds, struct pollfd);
1660 NETBSD32TO64_UAP(nfds);
1661 NETBSD32TO64_UAP(timeout);
1662
1663 return (sys_poll(l, &ua, retval));
1664 }
1665
1666 int
1667 netbsd32_fdatasync(struct lwp *l, const struct netbsd32_fdatasync_args *uap, register_t *retval)
1668 {
1669 /* {
1670 syscallarg(int) fd;
1671 } */
1672 struct sys_fdatasync_args ua;
1673
1674 NETBSD32TO64_UAP(fd);
1675 return (sys_fdatasync(l, &ua, retval));
1676 }
1677
1678 int
1679 netbsd32___posix_rename(struct lwp *l, const struct netbsd32___posix_rename_args *uap, register_t *retval)
1680 {
1681 /* {
1682 syscallarg(const netbsd32_charp) from;
1683 syscallarg(const netbsd32_charp) to;
1684 } */
1685 struct sys___posix_rename_args ua;
1686
1687 NETBSD32TOP_UAP(from, const char);
1688 NETBSD32TOP_UAP(to, const char);
1689 return (sys___posix_rename(l, &ua, retval));
1690 }
1691
1692 int
1693 netbsd32_swapctl(struct lwp *l, const struct netbsd32_swapctl_args *uap, register_t *retval)
1694 {
1695 /* {
1696 syscallarg(int) cmd;
1697 syscallarg(const netbsd32_voidp) arg;
1698 syscallarg(int) misc;
1699 } */
1700 struct sys_swapctl_args ua;
1701
1702 NETBSD32TO64_UAP(cmd);
1703 NETBSD32TOP_UAP(arg, void);
1704 NETBSD32TO64_UAP(misc);
1705 return (sys_swapctl(l, &ua, retval));
1706 }
1707
1708 int
1709 netbsd32_minherit(struct lwp *l, const struct netbsd32_minherit_args *uap, register_t *retval)
1710 {
1711 /* {
1712 syscallarg(netbsd32_voidp) addr;
1713 syscallarg(netbsd32_size_t) len;
1714 syscallarg(int) inherit;
1715 } */
1716 struct sys_minherit_args ua;
1717
1718 NETBSD32TOP_UAP(addr, void);
1719 NETBSD32TOX_UAP(len, size_t);
1720 NETBSD32TO64_UAP(inherit);
1721 return (sys_minherit(l, &ua, retval));
1722 }
1723
1724 int
1725 netbsd32_lchmod(struct lwp *l, const struct netbsd32_lchmod_args *uap, register_t *retval)
1726 {
1727 /* {
1728 syscallarg(const netbsd32_charp) path;
1729 syscallarg(mode_t) mode;
1730 } */
1731 struct sys_lchmod_args ua;
1732
1733 NETBSD32TOP_UAP(path, const char);
1734 NETBSD32TO64_UAP(mode);
1735 return (sys_lchmod(l, &ua, retval));
1736 }
1737
1738 int
1739 netbsd32_lchown(struct lwp *l, const struct netbsd32_lchown_args *uap, register_t *retval)
1740 {
1741 /* {
1742 syscallarg(const netbsd32_charp) path;
1743 syscallarg(uid_t) uid;
1744 syscallarg(gid_t) gid;
1745 } */
1746 struct sys_lchown_args ua;
1747
1748 NETBSD32TOP_UAP(path, const char);
1749 NETBSD32TO64_UAP(uid);
1750 NETBSD32TO64_UAP(gid);
1751 return (sys_lchown(l, &ua, retval));
1752 }
1753
1754 int
1755 netbsd32___msync13(struct lwp *l, const struct netbsd32___msync13_args *uap, register_t *retval)
1756 {
1757 /* {
1758 syscallarg(netbsd32_voidp) addr;
1759 syscallarg(netbsd32_size_t) len;
1760 syscallarg(int) flags;
1761 } */
1762 struct sys___msync13_args ua;
1763
1764 NETBSD32TOP_UAP(addr, void);
1765 NETBSD32TOX_UAP(len, size_t);
1766 NETBSD32TO64_UAP(flags);
1767 return (sys___msync13(l, &ua, retval));
1768 }
1769
1770 int
1771 netbsd32___posix_chown(struct lwp *l, const struct netbsd32___posix_chown_args *uap, register_t *retval)
1772 {
1773 /* {
1774 syscallarg(const netbsd32_charp) path;
1775 syscallarg(uid_t) uid;
1776 syscallarg(gid_t) gid;
1777 } */
1778 struct sys___posix_chown_args ua;
1779
1780 NETBSD32TOP_UAP(path, const char);
1781 NETBSD32TO64_UAP(uid);
1782 NETBSD32TO64_UAP(gid);
1783 return (sys___posix_chown(l, &ua, retval));
1784 }
1785
1786 int
1787 netbsd32___posix_fchown(struct lwp *l, const struct netbsd32___posix_fchown_args *uap, register_t *retval)
1788 {
1789 /* {
1790 syscallarg(int) fd;
1791 syscallarg(uid_t) uid;
1792 syscallarg(gid_t) gid;
1793 } */
1794 struct sys___posix_fchown_args ua;
1795
1796 NETBSD32TO64_UAP(fd);
1797 NETBSD32TO64_UAP(uid);
1798 NETBSD32TO64_UAP(gid);
1799 return (sys___posix_fchown(l, &ua, retval));
1800 }
1801
1802 int
1803 netbsd32___posix_lchown(struct lwp *l, const struct netbsd32___posix_lchown_args *uap, register_t *retval)
1804 {
1805 /* {
1806 syscallarg(const netbsd32_charp) path;
1807 syscallarg(uid_t) uid;
1808 syscallarg(gid_t) gid;
1809 } */
1810 struct sys___posix_lchown_args ua;
1811
1812 NETBSD32TOP_UAP(path, const char);
1813 NETBSD32TO64_UAP(uid);
1814 NETBSD32TO64_UAP(gid);
1815 return (sys___posix_lchown(l, &ua, retval));
1816 }
1817
1818 int
1819 netbsd32_getsid(struct lwp *l, const struct netbsd32_getsid_args *uap, register_t *retval)
1820 {
1821 /* {
1822 syscallarg(pid_t) pid;
1823 } */
1824 struct sys_getsid_args ua;
1825
1826 NETBSD32TO64_UAP(pid);
1827 return (sys_getsid(l, &ua, retval));
1828 }
1829
1830 int
1831 netbsd32_fktrace(struct lwp *l, const struct netbsd32_fktrace_args *uap, register_t *retval)
1832 {
1833 /* {
1834 syscallarg(int) fd;
1835 syscallarg(int) ops;
1836 syscallarg(int) facs;
1837 syscallarg(int) pid;
1838 } */
1839 struct sys_fktrace_args ua;
1840
1841 NETBSD32TOX_UAP(fd, int);
1842 NETBSD32TO64_UAP(ops);
1843 NETBSD32TO64_UAP(facs);
1844 NETBSD32TO64_UAP(pid);
1845 return (sys_fktrace(l, &ua, retval));
1846 }
1847
1848 int
1849 netbsd32___sigpending14(struct lwp *l, const struct netbsd32___sigpending14_args *uap, register_t *retval)
1850 {
1851 /* {
1852 syscallarg(sigset_t *) set;
1853 } */
1854 struct sys___sigpending14_args ua;
1855
1856 NETBSD32TOP_UAP(set, sigset_t);
1857 return (sys___sigpending14(l, &ua, retval));
1858 }
1859
1860 int
1861 netbsd32___sigprocmask14(struct lwp *l, const struct netbsd32___sigprocmask14_args *uap, register_t *retval)
1862 {
1863 /* {
1864 syscallarg(int) how;
1865 syscallarg(const sigset_t *) set;
1866 syscallarg(sigset_t *) oset;
1867 } */
1868 struct sys___sigprocmask14_args ua;
1869
1870 NETBSD32TO64_UAP(how);
1871 NETBSD32TOP_UAP(set, sigset_t);
1872 NETBSD32TOP_UAP(oset, sigset_t);
1873 return (sys___sigprocmask14(l, &ua, retval));
1874 }
1875
1876 int
1877 netbsd32___sigsuspend14(struct lwp *l, const struct netbsd32___sigsuspend14_args *uap, register_t *retval)
1878 {
1879 /* {
1880 syscallarg(const sigset_t *) set;
1881 } */
1882 struct sys___sigsuspend14_args ua;
1883
1884 NETBSD32TOP_UAP(set, sigset_t);
1885 return (sys___sigsuspend14(l, &ua, retval));
1886 };
1887
1888 int
1889 netbsd32_fchroot(struct lwp *l, const struct netbsd32_fchroot_args *uap, register_t *retval)
1890 {
1891 /* {
1892 syscallarg(int) fd;
1893 } */
1894 struct sys_fchroot_args ua;
1895
1896 NETBSD32TO64_UAP(fd);
1897 return (sys_fchroot(l, &ua, retval));
1898 }
1899
1900 /*
1901 * Open a file given a file handle.
1902 *
1903 * Check permissions, allocate an open file structure,
1904 * and call the device open routine if any.
1905 */
1906 int
1907 netbsd32___fhopen40(struct lwp *l, const struct netbsd32___fhopen40_args *uap, register_t *retval)
1908 {
1909 /* {
1910 syscallarg(const netbsd32_pointer_t *) fhp;
1911 syscallarg(netbsd32_size_t) fh_size;
1912 syscallarg(int) flags;
1913 } */
1914 struct sys___fhopen40_args ua;
1915
1916 NETBSD32TOP_UAP(fhp, fhandle_t);
1917 NETBSD32TO64_UAP(fh_size);
1918 NETBSD32TO64_UAP(flags);
1919 return (sys___fhopen40(l, &ua, retval));
1920 }
1921
1922 /* virtual memory syscalls */
1923 int
1924 netbsd32_ovadvise(struct lwp *l, const struct netbsd32_ovadvise_args *uap, register_t *retval)
1925 {
1926 /* {
1927 syscallarg(int) anom;
1928 } */
1929 struct sys_ovadvise_args ua;
1930
1931 NETBSD32TO64_UAP(anom);
1932 return (sys_ovadvise(l, &ua, retval));
1933 }
1934
1935 void
1936 netbsd32_adjust_limits(struct proc *p)
1937 {
1938 static const struct {
1939 int id;
1940 rlim_t lim;
1941 } lm[] = {
1942 { RLIMIT_DATA, MAXDSIZ32 },
1943 { RLIMIT_STACK, MAXSSIZ32 },
1944 };
1945 size_t i;
1946 struct plimit *lim;
1947 struct rlimit *rlim;
1948
1949 /*
1950 * We can only reduce the current limits, we cannot stop external
1951 * processes from changing them (eg via sysctl) later on.
1952 * So there is no point trying to lock out such changes here.
1953 *
1954 * If we assume that rlim_cur/max are accessed using atomic
1955 * operations, we don't need to lock against any other updates
1956 * that might happen if the plimit structure is shared writable
1957 * between multiple processes.
1958 */
1959
1960 /* Scan to determine is any limits are out of range */
1961 lim = p->p_limit;
1962 for (i = 0; ; i++) {
1963 if (i >= __arraycount(lm))
1964 /* All in range */
1965 return;
1966 rlim = lim->pl_rlimit + lm[i].id;
1967 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim))
1968 break;
1969 if (LIMITCHECK(rlim->rlim_max, lm[i].lim))
1970 break;
1971 }
1972
1973 lim_privatise(p, false);
1974
1975 lim = p->p_limit;
1976 for (i = 0; i < __arraycount(lm); i++) {
1977 rlim = lim->pl_rlimit + lm[i].id;
1978 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim))
1979 rlim->rlim_cur = lm[i].lim;
1980 if (LIMITCHECK(rlim->rlim_max, lm[i].lim))
1981 rlim->rlim_max = lm[i].lim;
1982 }
1983 }
1984
1985 int
1986 netbsd32_uuidgen(struct lwp *l, const struct netbsd32_uuidgen_args *uap, register_t *retval)
1987 {
1988 /* {
1989 syscallarg(netbsd32_uuidp_t) store;
1990 syscallarg(int) count;
1991 } */
1992 struct sys_uuidgen_args ua;
1993
1994 NETBSD32TOP_UAP(store, struct uuid);
1995 NETBSD32TO64_UAP(count);
1996 return (sys_uuidgen(l, &ua, retval));
1997 }
1998
1999 int
2000 netbsd32_extattrctl(struct lwp *l, const struct netbsd32_extattrctl_args *uap, register_t *retval)
2001 {
2002 /* {
2003 syscallarg(const netbsd32_charp) path;
2004 syscallarg(int) cmd;
2005 syscallarg(const netbsd32_charp) filename;
2006 syscallarg(int) attrnamespace;
2007 syscallarg(const netbsd32_charp) attrname;
2008 } */
2009 struct sys_extattrctl_args ua;
2010
2011 NETBSD32TOP_UAP(path, const char);
2012 NETBSD32TO64_UAP(cmd);
2013 NETBSD32TOP_UAP(filename, const char);
2014 NETBSD32TO64_UAP(attrnamespace);
2015 NETBSD32TOP_UAP(attrname, const char);
2016 return sys_extattrctl(l, &ua, retval);
2017 }
2018
2019 int
2020 netbsd32_extattr_set_fd(struct lwp *l, const struct netbsd32_extattr_set_fd_args *uap, register_t *retval)
2021 {
2022 /* {
2023 syscallarg(int) fd;
2024 syscallarg(int) attrnamespace;
2025 syscallarg(const netbsd32_charp) attrname;
2026 syscallarg(const netbsd32_voidp) data;
2027 syscallarg(netbsd32_size_t) nbytes;
2028 } */
2029 struct sys_extattr_set_fd_args ua;
2030
2031 NETBSD32TO64_UAP(fd);
2032 NETBSD32TO64_UAP(attrnamespace);
2033 NETBSD32TOP_UAP(attrname, const char);
2034 NETBSD32TOP_UAP(data, const void);
2035 NETBSD32TOX_UAP(nbytes, size_t);
2036 return sys_extattr_set_fd(l, &ua, retval);
2037 }
2038
2039 int
2040 netbsd32_extattr_set_file(struct lwp *l, const struct netbsd32_extattr_set_file_args *uap, register_t *retval)
2041 {
2042 /* {
2043 syscallarg(const netbsd32_charp) path;
2044 syscallarg(int) attrnamespace;
2045 syscallarg(const netbsd32_charp) attrname;
2046 syscallarg(const netbsd32_voidp) data;
2047 syscallarg(netbsd32_size_t) nbytes;
2048 } */
2049 struct sys_extattr_set_file_args ua;
2050
2051 NETBSD32TOP_UAP(path, const char);
2052 NETBSD32TO64_UAP(attrnamespace);
2053 NETBSD32TOP_UAP(attrname, const char);
2054 NETBSD32TOP_UAP(data, const void);
2055 NETBSD32TOX_UAP(nbytes, size_t);
2056 return sys_extattr_set_file(l, &ua, retval);
2057 }
2058
2059 int
2060 netbsd32_extattr_set_link(struct lwp *l, const struct netbsd32_extattr_set_link_args *uap, register_t *retval)
2061 {
2062 /* {
2063 syscallarg(const netbsd32_charp) path;
2064 syscallarg(int) attrnamespace;
2065 syscallarg(const netbsd32_charp) attrname;
2066 syscallarg(const netbsd32_voidp) data;
2067 syscallarg(netbsd32_size_t) nbytes;
2068 } */
2069 struct sys_extattr_set_link_args ua;
2070
2071 NETBSD32TOP_UAP(path, const char);
2072 NETBSD32TO64_UAP(attrnamespace);
2073 NETBSD32TOP_UAP(attrname, const char);
2074 NETBSD32TOP_UAP(data, const void);
2075 NETBSD32TOX_UAP(nbytes, size_t);
2076 return sys_extattr_set_link(l, &ua, retval);
2077 }
2078
2079 int
2080 netbsd32_extattr_get_fd(struct lwp *l, const struct netbsd32_extattr_get_fd_args *uap, register_t *retval)
2081 {
2082 /* {
2083 syscallarg(int) fd;
2084 syscallarg(int) attrnamespace;
2085 syscallarg(const netbsd32_charp) attrname;
2086 syscallarg(netbsd32_voidp) data;
2087 syscallarg(netbsd32_size_t) nbytes;
2088 } */
2089 struct sys_extattr_get_fd_args ua;
2090
2091 NETBSD32TO64_UAP(fd);
2092 NETBSD32TO64_UAP(attrnamespace);
2093 NETBSD32TOP_UAP(attrname, const char);
2094 NETBSD32TOP_UAP(data, void);
2095 NETBSD32TOX_UAP(nbytes, size_t);
2096 return sys_extattr_get_fd(l, &ua, retval);
2097 }
2098
2099 int
2100 netbsd32_extattr_get_file(struct lwp *l, const struct netbsd32_extattr_get_file_args *uap, register_t *retval)
2101 {
2102 /* {
2103 syscallarg(const netbsd32_charp) path;
2104 syscallarg(int) attrnamespace;
2105 syscallarg(const netbsd32_charp) attrname;
2106 syscallarg(netbsd32_voidp) data;
2107 syscallarg(netbsd32_size_t) nbytes;
2108 } */
2109 struct sys_extattr_get_file_args ua;
2110
2111 NETBSD32TOP_UAP(path, const char);
2112 NETBSD32TO64_UAP(attrnamespace);
2113 NETBSD32TOP_UAP(attrname, const char);
2114 NETBSD32TOP_UAP(data, void);
2115 NETBSD32TOX_UAP(nbytes, size_t);
2116 return sys_extattr_get_file(l, &ua, retval);
2117 }
2118
2119 int
2120 netbsd32_extattr_get_link(struct lwp *l, const struct netbsd32_extattr_get_link_args *uap, register_t *retval)
2121 {
2122 /* {
2123 syscallarg(const netbsd32_charp) path;
2124 syscallarg(int) attrnamespace;
2125 syscallarg(const netbsd32_charp) attrname;
2126 syscallarg(netbsd32_voidp) data;
2127 syscallarg(netbsd32_size_t) nbytes;
2128 } */
2129 struct sys_extattr_get_link_args ua;
2130
2131 NETBSD32TOP_UAP(path, const char);
2132 NETBSD32TO64_UAP(attrnamespace);
2133 NETBSD32TOP_UAP(attrname, const char);
2134 NETBSD32TOP_UAP(data, void);
2135 NETBSD32TOX_UAP(nbytes, size_t);
2136 return sys_extattr_get_link(l, &ua, retval);
2137 }
2138
2139 int
2140 netbsd32_extattr_delete_fd(struct lwp *l, const struct netbsd32_extattr_delete_fd_args *uap, register_t *retval)
2141 {
2142 /* {
2143 syscallarg(int) fd;
2144 syscallarg(int) attrnamespace;
2145 syscallarg(const netbsd32_charp) attrname;
2146 } */
2147 struct sys_extattr_delete_fd_args ua;
2148
2149 NETBSD32TO64_UAP(fd);
2150 NETBSD32TO64_UAP(attrnamespace);
2151 NETBSD32TOP_UAP(attrname, const char);
2152 return sys_extattr_delete_fd(l, &ua, retval);
2153 }
2154
2155 int
2156 netbsd32_extattr_delete_file(struct lwp *l, const struct netbsd32_extattr_delete_file_args *uap, register_t *retval)
2157 {
2158 /* {
2159 syscallarg(const netbsd32_charp) path;
2160 syscallarg(int) attrnamespace;
2161 syscallarg(const netbsd32_charp) attrname;
2162 } */
2163 struct sys_extattr_delete_file_args ua;
2164
2165 NETBSD32TOP_UAP(path, const char);
2166 NETBSD32TO64_UAP(attrnamespace);
2167 NETBSD32TOP_UAP(attrname, const char);
2168 return sys_extattr_delete_file(l, &ua, retval);
2169 }
2170
2171 int
2172 netbsd32_extattr_delete_link(struct lwp *l, const struct netbsd32_extattr_delete_link_args *uap, register_t *retval)
2173 {
2174 /* {
2175 syscallarg(const netbsd32_charp) path;
2176 syscallarg(int) attrnamespace;
2177 syscallarg(const netbsd32_charp) attrname;
2178 } */
2179 struct sys_extattr_delete_link_args ua;
2180
2181 NETBSD32TOP_UAP(path, const char);
2182 NETBSD32TO64_UAP(attrnamespace);
2183 NETBSD32TOP_UAP(attrname, const char);
2184 return sys_extattr_delete_link(l, &ua, retval);
2185 }
2186
2187 int
2188 netbsd32_extattr_list_fd(struct lwp *l, const struct netbsd32_extattr_list_fd_args *uap, register_t *retval)
2189 {
2190 /* {
2191 syscallarg(int) fd;
2192 syscallarg(int) attrnamespace;
2193 syscallarg(netbsd32_voidp) data;
2194 syscallarg(netbsd32_size_t) nbytes;
2195 } */
2196 struct sys_extattr_list_fd_args ua;
2197
2198 NETBSD32TO64_UAP(fd);
2199 NETBSD32TO64_UAP(attrnamespace);
2200 NETBSD32TOP_UAP(data, void);
2201 NETBSD32TOX_UAP(nbytes, size_t);
2202 return sys_extattr_list_fd(l, &ua, retval);
2203 }
2204
2205 int
2206 netbsd32_extattr_list_file(struct lwp *l, const struct netbsd32_extattr_list_file_args *uap, register_t *retval)
2207 {
2208 /* {
2209 syscallarg(const netbsd32_charp) path;
2210 syscallarg(int) attrnamespace;
2211 syscallarg(netbsd32_voidp) data;
2212 syscallarg(netbsd32_size_t) nbytes;
2213 } */
2214 struct sys_extattr_list_file_args ua;
2215
2216 NETBSD32TOP_UAP(path, const char);
2217 NETBSD32TO64_UAP(attrnamespace);
2218 NETBSD32TOP_UAP(data, void);
2219 NETBSD32TOX_UAP(nbytes, size_t);
2220 return sys_extattr_list_file(l, &ua, retval);
2221 }
2222
2223 int
2224 netbsd32_extattr_list_link(struct lwp *l, const struct netbsd32_extattr_list_link_args *uap, register_t *retval)
2225 {
2226 /* {
2227 syscallarg(const netbsd32_charp) path;
2228 syscallarg(int) attrnamespace;
2229 syscallarg(netbsd32_voidp) data;
2230 syscallarg(netbsd32_size_t) nbytes;
2231 } */
2232 struct sys_extattr_list_link_args ua;
2233
2234 NETBSD32TOP_UAP(path, const char);
2235 NETBSD32TO64_UAP(attrnamespace);
2236 NETBSD32TOP_UAP(data, void);
2237 NETBSD32TOX_UAP(nbytes, size_t);
2238 return sys_extattr_list_link(l, &ua, retval);
2239 }
2240
2241 int
2242 netbsd32_mlockall(struct lwp *l, const struct netbsd32_mlockall_args *uap, register_t *retval)
2243 {
2244 /* {
2245 syscallarg(int) flags;
2246 } */
2247 struct sys_mlockall_args ua;
2248
2249 NETBSD32TO64_UAP(flags);
2250 return (sys_mlockall(l, &ua, retval));
2251 }
2252
2253 int
2254 netbsd32___clone(struct lwp *l, const struct netbsd32___clone_args *uap, register_t *retval)
2255 {
2256 /* {
2257 syscallarg(int) flags;
2258 syscallarg(netbsd32_voidp) stack;
2259 } */
2260 struct sys___clone_args ua;
2261
2262 NETBSD32TO64_UAP(flags);
2263 NETBSD32TOP_UAP(stack, void);
2264 return sys___clone(l, &ua, retval);
2265 }
2266
2267 int
2268 netbsd32_fsync_range(struct lwp *l, const struct netbsd32_fsync_range_args *uap, register_t *retval)
2269 {
2270 /* {
2271 syscallarg(int) fd;
2272 syscallarg(int) flags;
2273 syscallarg(off_t) start;
2274 syscallarg(off_t) length;
2275 } */
2276 struct sys_fsync_range_args ua;
2277
2278 NETBSD32TO64_UAP(fd);
2279 NETBSD32TO64_UAP(flags);
2280 NETBSD32TO64_UAP(start);
2281 NETBSD32TO64_UAP(length);
2282 return (sys_fsync_range(l, &ua, retval));
2283 }
2284
2285 int
2286 netbsd32_rasctl(struct lwp *l, const struct netbsd32_rasctl_args *uap, register_t *retval)
2287 {
2288 /* {
2289 syscallarg(netbsd32_voidp) addr;
2290 syscallarg(netbsd32_size_t) len;
2291 syscallarg(int) op;
2292 } */
2293 struct sys_rasctl_args ua;
2294
2295 NETBSD32TOP_UAP(addr, void *);
2296 NETBSD32TOX_UAP(len, size_t);
2297 NETBSD32TO64_UAP(op);
2298 return sys_rasctl(l, &ua, retval);
2299 }
2300
2301 int
2302 netbsd32_setxattr(struct lwp *l, const struct netbsd32_setxattr_args *uap, register_t *retval)
2303 {
2304 /* {
2305 syscallarg(const netbsd32_charp) path;
2306 syscallarg(const netbsd32_charp) name;
2307 syscallarg(netbsd32_voidp) value;
2308 syscallarg(netbsd32_size_t) size;
2309 syscallarg(int) flags;
2310 } */
2311 struct sys_setxattr_args ua;
2312 NETBSD32TOP_UAP(path, const char);
2313 NETBSD32TOP_UAP(name, const char);
2314 NETBSD32TOP_UAP(value, void);
2315 NETBSD32TOX_UAP(size, size_t);
2316 NETBSD32TO64_UAP(flags);
2317 return sys_setxattr(l, &ua, retval);
2318 }
2319
2320 int
2321 netbsd32_lsetxattr(struct lwp *l, const struct netbsd32_lsetxattr_args *uap, register_t *retval)
2322 {
2323 /* {
2324 syscallarg(const netbsd32_charp) path;
2325 syscallarg(const netbsd32_charp) name;
2326 syscallarg(netbsd32_voidp) value;
2327 syscallarg(netbsd32_size_t) size;
2328 syscallarg(int) flags;
2329 } */
2330 struct sys_lsetxattr_args ua;
2331 NETBSD32TOP_UAP(path, const char);
2332 NETBSD32TOP_UAP(name, const char);
2333 NETBSD32TOP_UAP(value, void);
2334 NETBSD32TOX_UAP(size, size_t);
2335 NETBSD32TO64_UAP(flags);
2336 return sys_lsetxattr(l, &ua, retval);
2337 }
2338
2339 int
2340 netbsd32_fsetxattr(struct lwp *l, const struct netbsd32_fsetxattr_args *uap, register_t *retval)
2341 {
2342 /* {
2343 syscallarg(int) fd;
2344 syscallarg(const netbsd32_charp) name;
2345 syscallarg(netbsd32_voidp) value;
2346 syscallarg(netbsd32_size_t) size;
2347 syscallarg(int) flags;
2348 } */
2349 struct sys_fsetxattr_args ua;
2350 NETBSD32TO64_UAP(fd);
2351 NETBSD32TOP_UAP(name, const char);
2352 NETBSD32TOP_UAP(value, void);
2353 NETBSD32TOX_UAP(size, size_t);
2354 NETBSD32TO64_UAP(flags);
2355 return sys_fsetxattr(l, &ua, retval);
2356 }
2357
2358 int
2359 netbsd32_getxattr(struct lwp *l, const struct netbsd32_getxattr_args *uap, register_t *retval)
2360 {
2361 /* {
2362 syscallarg(const netbsd32_charp) path;
2363 syscallarg(const netbsd32_charp) name;
2364 syscallarg(netbsd32_voidp) value;
2365 syscallarg(netbsd32_size_t) size;
2366 } */
2367 struct sys_getxattr_args ua;
2368 NETBSD32TOP_UAP(path, const char);
2369 NETBSD32TOP_UAP(name, const char);
2370 NETBSD32TOP_UAP(value, void);
2371 NETBSD32TOX_UAP(size, size_t);
2372 return sys_getxattr(l, &ua, retval);
2373 }
2374
2375 int
2376 netbsd32_lgetxattr(struct lwp *l, const struct netbsd32_lgetxattr_args *uap, register_t *retval)
2377 {
2378 /* {
2379 syscallarg(const netbsd32_charp) path;
2380 syscallarg(const netbsd32_charp) name;
2381 syscallarg(netbsd32_voidp) value;
2382 syscallarg(netbsd32_size_t) size;
2383 } */
2384 struct sys_lgetxattr_args ua;
2385 NETBSD32TOP_UAP(path, const char);
2386 NETBSD32TOP_UAP(name, const char);
2387 NETBSD32TOP_UAP(value, void);
2388 NETBSD32TOX_UAP(size, size_t);
2389 return sys_lgetxattr(l, &ua, retval);
2390 }
2391
2392 int
2393 netbsd32_fgetxattr(struct lwp *l, const struct netbsd32_fgetxattr_args *uap, register_t *retval)
2394 {
2395 /* {
2396 syscallarg(int) fd;
2397 syscallarg(const netbsd32_charp) name;
2398 syscallarg(netbsd32_voidp) value;
2399 syscallarg(netbsd32_size_t) size;
2400 } */
2401 struct sys_fgetxattr_args ua;
2402 NETBSD32TO64_UAP(fd);
2403 NETBSD32TOP_UAP(name, const char);
2404 NETBSD32TOP_UAP(value, void);
2405 NETBSD32TOX_UAP(size, size_t);
2406 return sys_fgetxattr(l, &ua, retval);
2407 }
2408
2409 int
2410 netbsd32_listxattr(struct lwp *l, const struct netbsd32_listxattr_args *uap, register_t *retval)
2411 {
2412 /* {
2413 syscallarg(const netbsd32_charp) path;
2414 syscallarg(netbsd32_charp) list;
2415 syscallarg(netbsd32_size_t) size;
2416 } */
2417 struct sys_listxattr_args ua;
2418 NETBSD32TOP_UAP(path, const char);
2419 NETBSD32TOP_UAP(list, char);
2420 NETBSD32TOX_UAP(size, size_t);
2421 return sys_listxattr(l, &ua, retval);
2422 }
2423
2424 int
2425 netbsd32_llistxattr(struct lwp *l, const struct netbsd32_llistxattr_args *uap, register_t *retval)
2426 {
2427 /* {
2428 syscallarg(const netbsd32_charp) path;
2429 syscallarg(netbsd32_charp) list;
2430 syscallarg(netbsd32_size_t) size;
2431 } */
2432 struct sys_llistxattr_args ua;
2433 NETBSD32TOP_UAP(path, const char);
2434 NETBSD32TOP_UAP(list, char);
2435 NETBSD32TOX_UAP(size, size_t);
2436 return sys_llistxattr(l, &ua, retval);
2437 }
2438
2439 int
2440 netbsd32_flistxattr(struct lwp *l, const struct netbsd32_flistxattr_args *uap, register_t *retval)
2441 {
2442 /* {
2443 syscallarg(int) fd;
2444 syscallarg(netbsd32_charp) list;
2445 syscallarg(netbsd32_size_t) size;
2446 } */
2447 struct sys_flistxattr_args ua;
2448 NETBSD32TO64_UAP(fd);
2449 NETBSD32TOP_UAP(list, char);
2450 NETBSD32TOX_UAP(size, size_t);
2451 return sys_flistxattr(l, &ua, retval);
2452 }
2453
2454 int
2455 netbsd32_removexattr(struct lwp *l, const struct netbsd32_removexattr_args *uap, register_t *retval)
2456 {
2457 /* {
2458 syscallarg(const netbsd32_charp) path;
2459 syscallarg(const netbsd32_charp) name;
2460 } */
2461 struct sys_removexattr_args ua;
2462 NETBSD32TOP_UAP(path, const char);
2463 NETBSD32TOP_UAP(name, const char);
2464 return sys_removexattr(l, &ua, retval);
2465 }
2466
2467 int
2468 netbsd32_lremovexattr(struct lwp *l, const struct netbsd32_lremovexattr_args *uap, register_t *retval)
2469 {
2470 /* {
2471 syscallarg(const netbsd32_charp) path;
2472 syscallarg(const netbsd32_charp) name;
2473 } */
2474 struct sys_lremovexattr_args ua;
2475 NETBSD32TOP_UAP(path, const char);
2476 NETBSD32TOP_UAP(name, const char);
2477 return sys_lremovexattr(l, &ua, retval);
2478 }
2479
2480 int
2481 netbsd32_fremovexattr(struct lwp *l, const struct netbsd32_fremovexattr_args *uap, register_t *retval)
2482 {
2483 /* {
2484 syscallarg(int) fd;
2485 syscallarg(const netbsd32_charp) name;
2486 } */
2487 struct sys_fremovexattr_args ua;
2488 NETBSD32TO64_UAP(fd);
2489 NETBSD32TOP_UAP(name, const char);
2490 return sys_fremovexattr(l, &ua, retval);
2491 }
2492
2493 int
2494 netbsd32___posix_fadvise50(struct lwp *l,
2495 const struct netbsd32___posix_fadvise50_args *uap, register_t *retval)
2496 {
2497 /* {
2498 syscallarg(int) fd;
2499 syscallarg(int) PAD;
2500 syscallarg(off_t) offset;
2501 syscallarg(off_t) len;
2502 syscallarg(int) advice;
2503 } */
2504
2505 *retval = do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset),
2506 SCARG(uap, len), SCARG(uap, advice));
2507
2508 return 0;
2509 }
2510
2511 int
2512 netbsd32__sched_setparam(struct lwp *l,
2513 const struct netbsd32__sched_setparam_args *uap,
2514 register_t *retval)
2515 {
2516 /* {
2517 syscallarg(pid_t) pid;
2518 syscallarg(lwpid_t) lid;
2519 syscallarg(int) policy;
2520 syscallarg(const netbsd32_sched_paramp_t) params;
2521 } */
2522 struct sys__sched_setparam_args ua;
2523
2524 NETBSD32TO64_UAP(pid);
2525 NETBSD32TO64_UAP(lid);
2526 NETBSD32TO64_UAP(policy);
2527 NETBSD32TOP_UAP(params, const struct sched_param *);
2528 return sys__sched_setparam(l, &ua, retval);
2529 }
2530
2531 int
2532 netbsd32__sched_getparam(struct lwp *l,
2533 const struct netbsd32__sched_getparam_args *uap,
2534 register_t *retval)
2535 {
2536 /* {
2537 syscallarg(pid_t) pid;
2538 syscallarg(lwpid_t) lid;
2539 syscallarg(netbsd32_intp) policy;
2540 syscallarg(netbsd32_sched_paramp_t) params;
2541 } */
2542 struct sys__sched_getparam_args ua;
2543
2544 NETBSD32TO64_UAP(pid);
2545 NETBSD32TO64_UAP(lid);
2546 NETBSD32TOP_UAP(policy, int *);
2547 NETBSD32TOP_UAP(params, struct sched_param *);
2548 return sys__sched_getparam(l, &ua, retval);
2549 }
2550
2551 int
2552 netbsd32__sched_setaffinity(struct lwp *l,
2553 const struct netbsd32__sched_setaffinity_args *uap,
2554 register_t *retval)
2555 {
2556 /* {
2557 syscallarg(pid_t) pid;
2558 syscallarg(lwpid_t) lid;
2559 syscallarg(netbsd_size_t) size;
2560 syscallarg(const netbsd32_cpusetp_t) cpuset;
2561 } */
2562 struct sys__sched_setaffinity_args ua;
2563
2564 NETBSD32TO64_UAP(pid);
2565 NETBSD32TO64_UAP(lid);
2566 NETBSD32TOX_UAP(size, size_t);
2567 NETBSD32TOP_UAP(cpuset, const cpuset_t *);
2568 return sys__sched_setaffinity(l, &ua, retval);
2569 }
2570
2571 int
2572 netbsd32__sched_getaffinity(struct lwp *l,
2573 const struct netbsd32__sched_getaffinity_args *uap,
2574 register_t *retval)
2575 {
2576 /* {
2577 syscallarg(pid_t) pid;
2578 syscallarg(lwpid_t) lid;
2579 syscallarg(netbsd_size_t) size;
2580 syscallarg(netbsd32_cpusetp_t) cpuset;
2581 } */
2582 struct sys__sched_getaffinity_args ua;
2583
2584 NETBSD32TO64_UAP(pid);
2585 NETBSD32TO64_UAP(lid);
2586 NETBSD32TOX_UAP(size, size_t);
2587 NETBSD32TOP_UAP(cpuset, cpuset_t *);
2588 return sys__sched_getaffinity(l, &ua, retval);
2589 }
2590
2591 /*
2592 * MI indirect system call support.
2593 * Only used if the MD netbsd32_syscall.c doesn't intercept the calls.
2594 */
2595
2596 #define NETBSD32_SYSCALL
2597 #undef SYS_NSYSENT
2598 #define SYS_NSYSENT NETBSD32_SYS_NSYSENT
2599
2600 #define SYS_SYSCALL netbsd32_syscall
2601 #include "../../kern/sys_syscall.c"
2602 #undef SYS_SYSCALL
2603
2604 #define SYS_SYSCALL netbsd32____syscall
2605 #include "../../kern/sys_syscall.c"
2606 #undef SYS_SYSCALL
NetBSD on the FriendlyARM MINI2440