1/* $NetBSD: netbsd32_compat_50.c,v 1.32 2015/12/03 10:38:21 pgoyette Exp $ */
2
3/*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Christos Zoulas.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38#include <sys/cdefs.h>
39__KERNEL_RCSID(0, "$NetBSD: netbsd32_compat_50.c,v 1.32 2015/12/03 10:38:21 pgoyette Exp $");
40
41#if defined(_KERNEL_OPT)
42#include "opt_compat_netbsd.h"
43#endif
44
45#include <sys/param.h>
46#include <sys/systm.h>
47#include <sys/mount.h>
48#include <sys/socket.h>
49#include <sys/socketvar.h>
50#include <sys/stat.h>
51#include <sys/time.h>
52#include <sys/ktrace.h>
53#include <sys/eventvar.h>
54#include <sys/resourcevar.h>
55#include <sys/vnode.h>
56#include <sys/file.h>
57#include <sys/filedesc.h>
58#include <sys/poll.h>
59#include <sys/namei.h>
60#include <sys/statvfs.h>
61#include <sys/syscallargs.h>
62#include <sys/proc.h>
63#include <sys/dirent.h>
64#include <sys/kauth.h>
65#include <sys/vfs_syscalls.h>
66
67#include <compat/netbsd32/netbsd32.h>
68#include <compat/netbsd32/netbsd32_syscallargs.h>
69#include <compat/netbsd32/netbsd32_conv.h>
70#include <compat/sys/mount.h>
71#include <compat/sys/time.h>
72
73#if defined(COMPAT_50)
74
75/*
76 * Common routine to set access and modification times given a vnode.
77 */
78static int
79get_utimes32(const netbsd32_timeval50p_t *tptr, struct timeval *tv,
80 struct timeval **tvp)
81{
82 int error;
83 struct netbsd32_timeval50 tv32[2];
84
85 if (tptr == NULL) {
86 *tvp = NULL;
87 return 0;
88 }
89
90 error = copyin(tptr, tv32, sizeof(tv32));
91 if (error)
92 return error;
93 netbsd32_to_timeval50(&tv32[0], &tv[0]);
94 netbsd32_to_timeval50(&tv32[1], &tv[1]);
95
96 *tvp = tv;
97 return 0;
98}
99
100int
101compat_50_netbsd32_mknod(struct lwp *l,
102 const struct compat_50_netbsd32_mknod_args *uap, register_t *retval)
103{
104 /* {
105 syscallarg(netbsd32_charp) path;
106 syscallarg(mode_t) mode;
107 syscallarg(uint32_t) dev;
108 } */
109 return do_sys_mknod(l, SCARG_P32(uap, path), SCARG(uap, mode),
110 SCARG(uap, dev), retval, UIO_USERSPACE);
111}
112
113int
114compat_50_netbsd32_select(struct lwp *l,
115 const struct compat_50_netbsd32_select_args *uap, register_t *retval)
116{
117 /* {
118 syscallarg(int) nd;
119 syscallarg(netbsd32_fd_setp_t) in;
120 syscallarg(netbsd32_fd_setp_t) ou;
121 syscallarg(netbsd32_fd_setp_t) ex;
122 syscallarg(netbsd32_timeval50p_t) tv;
123 } */
124 int error;
125 struct netbsd32_timeval50 tv32;
126 struct timespec ats, *ts = NULL;
127
128 if (SCARG_P32(uap, tv)) {
129 error = copyin(SCARG_P32(uap, tv), &tv32, sizeof(tv32));
130 if (error != 0)
131 return error;
132 ats.tv_sec = tv32.tv_sec;
133 ats.tv_nsec = tv32.tv_usec * 1000;
134 ts = &ats;
135 }
136
137 return selcommon(retval, SCARG(uap, nd), SCARG_P32(uap, in),
138 SCARG_P32(uap, ou), SCARG_P32(uap, ex), ts, NULL);
139}
140
141int
142compat_50_netbsd32_gettimeofday(struct lwp *l,
143 const struct compat_50_netbsd32_gettimeofday_args *uap, register_t *retval)
144{
145 /* {
146 syscallarg(netbsd32_timeval50p_t) tp;
147 syscallarg(netbsd32_timezonep_t) tzp;
148 } */
149 struct timeval atv;
150 struct netbsd32_timeval50 tv32;
151 int error = 0;
152 struct netbsd32_timezone tzfake;
153
154 if (SCARG_P32(uap, tp)) {
155 microtime(&atv);
156 netbsd32_from_timeval50(&atv, &tv32);
157 error = copyout(&tv32, SCARG_P32(uap, tp), sizeof(tv32));
158 if (error)
159 return error;
160 }
161 if (SCARG_P32(uap, tzp)) {
162 /*
163 * NetBSD has no kernel notion of time zone, so we just
164 * fake up a timezone struct and return it if demanded.
165 */
166 tzfake.tz_minuteswest = 0;
167 tzfake.tz_dsttime = 0;
168 error = copyout(&tzfake, SCARG_P32(uap, tzp), sizeof(tzfake));
169 }
170 return error;
171}
172
173int
174compat_50_netbsd32_settimeofday(struct lwp *l,
175 const struct compat_50_netbsd32_settimeofday_args *uap, register_t *retval)
176{
177 /* {
178 syscallarg(const netbsd32_timeval50p_t) tv;
179 syscallarg(const netbsd32_timezonep_t) tzp;
180 } */
181 struct netbsd32_timeval50 atv32;
182 struct timeval atv;
183 struct timespec ats;
184 int error;
185 struct proc *p = l->l_proc;
186
187 /* Verify all parameters before changing time. */
188
189 /*
190 * NetBSD has no kernel notion of time zone, and only an
191 * obsolete program would try to set it, so we log a warning.
192 */
193 if (SCARG_P32(uap, tzp))
194 printf("pid %d attempted to set the "
195 "(obsolete) kernel time zone\n", p->p_pid);
196
197 if (SCARG_P32(uap, tv) == 0)
198 return 0;
199
200 if ((error = copyin(SCARG_P32(uap, tv), &atv32, sizeof(atv32))) != 0)
201 return error;
202
203 netbsd32_to_timeval50(&atv32, &atv);
204 TIMEVAL_TO_TIMESPEC(&atv, &ats);
205 return settime(p, &ats);
206}
207
208int
209compat_50_netbsd32_utimes(struct lwp *l,
210 const struct compat_50_netbsd32_utimes_args *uap, register_t *retval)
211{
212 /* {
213 syscallarg(const netbsd32_charp) path;
214 syscallarg(const netbsd32_timeval50p_t) tptr;
215 } */
216 int error;
217 struct timeval tv[2], *tvp;
218
219 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
220 if (error != 0)
221 return error;
222
223 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW,
224 tvp, UIO_SYSSPACE);
225}
226
227int
228compat_50_netbsd32_adjtime(struct lwp *l,
229 const struct compat_50_netbsd32_adjtime_args *uap, register_t *retval)
230{
231 /* {
232 syscallarg(const netbsd32_timeval50p_t) delta;
233 syscallarg(netbsd32_timeval50p_t) olddelta;
234 } */
235 struct netbsd32_timeval50 atv;
236 int error;
237
238 extern int time_adjusted; /* in kern_ntptime.c */
239 extern int64_t time_adjtime; /* in kern_ntptime.c */
240
241 if ((error = kauth_authorize_system(l->l_cred,
242 KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL,
243 NULL)) != 0)
244 return (error);
245
246 if (SCARG_P32(uap, olddelta)) {
247 mutex_spin_enter(&timecounter_lock);
248 atv.tv_sec = time_adjtime / 1000000;
249 atv.tv_usec = time_adjtime % 1000000;
250 if (atv.tv_usec < 0) {
251 atv.tv_usec += 1000000;
252 atv.tv_sec--;
253 }
254 mutex_spin_exit(&timecounter_lock);
255
256 error = copyout(&atv, SCARG_P32(uap, olddelta), sizeof(atv));
257 if (error)
258 return (error);
259 }
260
261 if (SCARG_P32(uap, delta)) {
262 error = copyin(SCARG_P32(uap, delta), &atv, sizeof(atv));
263 if (error)
264 return (error);
265
266 mutex_spin_enter(&timecounter_lock);
267 time_adjtime = (int64_t)atv.tv_sec * 1000000 + atv.tv_usec;
268 if (time_adjtime)
269 /* We need to save the system time during shutdown */
270 time_adjusted |= 1;
271 mutex_spin_exit(&timecounter_lock);
272 }
273
274 return 0;
275}
276
277int
278compat_50_netbsd32_futimes(struct lwp *l,
279 const struct compat_50_netbsd32_futimes_args *uap, register_t *retval)
280{
281 /* {
282 syscallarg(int) fd;
283 syscallarg(const netbsd32_timeval50p_t) tptr;
284 } */
285 int error;
286 file_t *fp;
287 struct timeval tv[2], *tvp;
288
289 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
290 if (error != 0)
291 return error;
292
293 /* fd_getvnode() will use the descriptor for us */
294 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
295 return error;
296
297 error = do_sys_utimes(l, fp->f_vnode, NULL, 0, tvp, UIO_SYSSPACE);
298
299 fd_putfile(SCARG(uap, fd));
300 return error;
301}
302
303int
304compat_50_netbsd32_clock_gettime(struct lwp *l,
305 const struct compat_50_netbsd32_clock_gettime_args *uap, register_t *retval)
306{
307 /* {
308 syscallarg(netbsd32_clockid_t) clock_id;
309 syscallarg(netbsd32_timespec50p_t) tp;
310 } */
311 int error;
312 struct timespec ats;
313 struct netbsd32_timespec50 ts32;
314
315 error = clock_gettime1(SCARG(uap, clock_id), &ats);
316 if (error != 0)
317 return error;
318
319 netbsd32_from_timespec50(&ats, &ts32);
320 return copyout(&ts32, SCARG_P32(uap, tp), sizeof(ts32));
321}
322
323int
324compat_50_netbsd32_clock_settime(struct lwp *l,
325 const struct compat_50_netbsd32_clock_settime_args *uap, register_t *retval)
326{
327 /* {
328 syscallarg(netbsd32_clockid_t) clock_id;
329 syscallarg(const netbsd32_timespec50p_t) tp;
330 } */
331 struct netbsd32_timespec50 ts32;
332 struct timespec ats;
333 int error;
334
335 if ((error = copyin(SCARG_P32(uap, tp), &ts32, sizeof(ts32))) != 0)
336 return (error);
337
338 netbsd32_to_timespec50(&ts32, &ats);
339 return clock_settime1(l->l_proc, SCARG(uap, clock_id), &ats, true);
340}
341
342int
343compat_50_netbsd32_clock_getres(struct lwp *l,
344 const struct compat_50_netbsd32_clock_getres_args *uap, register_t *retval)
345{
346 /* {
347 syscallarg(netbsd32_clockid_t) clock_id;
348 syscallarg(netbsd32_timespec50p_t) tp;
349 } */
350 struct netbsd32_timespec50 ts32;
351 struct timespec ts;
352 int error;
353
354 error = clock_getres1(SCARG(uap, clock_id), &ts);
355 if (error != 0)
356 return error;
357
358 if (SCARG_P32(uap, tp)) {
359 netbsd32_from_timespec50(&ts, &ts32);
360 error = copyout(&ts32, SCARG_P32(uap, tp), sizeof(ts32));
361 }
362
363 return error;
364}
365
366int
367compat_50_netbsd32_timer_settime(struct lwp *l,
368 const struct compat_50_netbsd32_timer_settime_args *uap, register_t *retval)
369{
370 /* {
371 syscallarg(netbsd32_timer_t) timerid;
372 syscallarg(int) flags;
373 syscallarg(const netbsd32_itimerspec50p_t) value;
374 syscallarg(netbsd32_itimerspec50p_t) ovalue;
375 } */
376 int error;
377 struct itimerspec value, ovalue, *ovp = NULL;
378 struct netbsd32_itimerspec50 its32;
379
380 if ((error = copyin(SCARG_P32(uap, value), &its32, sizeof(its32))) != 0)
381 return (error);
382 netbsd32_to_timespec50(&its32.it_interval, &value.it_interval);
383 netbsd32_to_timespec50(&its32.it_value, &value.it_value);
384
385 if (SCARG_P32(uap, ovalue))
386 ovp = &ovalue;
387
388 if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp,
389 SCARG(uap, flags), l->l_proc)) != 0)
390 return error;
391
392 if (ovp) {
393 netbsd32_from_timespec50(&ovp->it_interval, &its32.it_interval);
394 netbsd32_from_timespec50(&ovp->it_value, &its32.it_value);
395 return copyout(&its32, SCARG_P32(uap, ovalue), sizeof(its32));
396 }
397 return 0;
398}
399
400int
401compat_50_netbsd32_timer_gettime(struct lwp *l, const struct compat_50_netbsd32_timer_gettime_args *uap, register_t *retval)
402{
403 /* {
404 syscallarg(netbsd32_timer_t) timerid;
405 syscallarg(netbsd32_itimerspec50p_t) value;
406 } */
407 int error;
408 struct itimerspec its;
409 struct netbsd32_itimerspec50 its32;
410
411 if ((error = dotimer_gettime(SCARG(uap, timerid), l->l_proc,
412 &its)) != 0)
413 return error;
414
415 netbsd32_from_timespec50(&its.it_interval, &its32.it_interval);
416 netbsd32_from_timespec50(&its.it_value, &its32.it_value);
417
418 return copyout(&its32, SCARG_P32(uap, value), sizeof(its32));
419}
420
421int
422compat_50_netbsd32_nanosleep(struct lwp *l,
423 const struct compat_50_netbsd32_nanosleep_args *uap, register_t *retval)
424{
425 /* {
426 syscallarg(const netbsd32_timespec50p_t) rqtp;
427 syscallarg(netbsd32_timespecp_t) rmtp;
428 } */
429 struct netbsd32_timespec50 ts32;
430 struct timespec rqt, rmt;
431 int error, error1;
432
433 error = copyin(SCARG_P32(uap, rqtp), &ts32, sizeof(ts32));
434 if (error)
435 return (error);
436 netbsd32_to_timespec50(&ts32, &rqt);
437
438 error = nanosleep1(l, CLOCK_MONOTONIC, 0, &rqt,
439 SCARG_P32(uap, rmtp) ? &rmt : NULL);
440 if (SCARG_P32(uap, rmtp) == NULL || (error != 0 && error != EINTR))
441 return error;
442
443 netbsd32_from_timespec50(&rmt, &ts32);
444 error1 = copyout(&ts32, SCARG_P32(uap,rmtp), sizeof(ts32));
445 return error1 ? error1 : error;
446}
447
448static int
449compat_50_netbsd32_sigtimedwait_put_info(const void *src, void *dst, size_t size)
450{
451 const siginfo_t *info = src;
452 siginfo32_t info32;
453
454 netbsd32_si_to_si32(&info32, info);
455
456 return copyout(&info32, dst, sizeof(info32));
457}
458
459static int
460compat_50_netbsd32_sigtimedwait_fetch_timeout(const void *src, void *dst, size_t size)
461{
462 struct timespec *ts = dst;
463 struct netbsd32_timespec50 ts32;
464 int error;
465
466 error = copyin(src, &ts32, sizeof(ts32));
467 if (error)
468 return error;
469
470 netbsd32_to_timespec50(&ts32, ts);
471 return 0;
472}
473
474static int
475compat_50_netbsd32_sigtimedwait_put_timeout(const void *src, void *dst, size_t size)
476{
477 const struct timespec *ts = src;
478 struct netbsd32_timespec50 ts32;
479
480 netbsd32_from_timespec50(ts, &ts32);
481
482 return copyout(&ts32, dst, sizeof(ts32));
483}
484
485int
486compat_50_netbsd32___sigtimedwait(struct lwp *l,
487 const struct compat_50_netbsd32___sigtimedwait_args *uap, register_t *retval)
488{
489 /* {
490 syscallarg(netbsd32_sigsetp_t) set;
491 syscallarg(netbsd32_siginfop_t) info;
492 syscallarg(netbsd32_timespec50p_t) timeout;
493 } */
494 struct sys_____sigtimedwait50_args ua;
495 int res;
496
497 NETBSD32TOP_UAP(set, const sigset_t);
498 NETBSD32TOP_UAP(info, siginfo_t);
499 NETBSD32TOP_UAP(timeout, struct timespec);
500
501 res = sigtimedwait1(l, &ua, retval,
502 copyin,
503 compat_50_netbsd32_sigtimedwait_put_info,
504 compat_50_netbsd32_sigtimedwait_fetch_timeout,
505 compat_50_netbsd32_sigtimedwait_put_timeout);
506 if (!res)
507 *retval = 0; /* XXX NetBSD<=5 was not POSIX compliant */
508 return res;
509}
510
511int
512compat_50_netbsd32_lutimes(struct lwp *l,
513 const struct compat_50_netbsd32_lutimes_args *uap, register_t *retval)
514{
515 /* {
516 syscallarg(const netbsd32_charp) path;
517 syscallarg(const netbsd32_timeval50p_t) tptr;
518 } */
519 int error;
520 struct timeval tv[2], *tvp;
521
522 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
523 if (error != 0)
524 return error;
525
526 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW,
527 tvp, UIO_SYSSPACE);
528}
529
530int
531compat_50_netbsd32__lwp_park(struct lwp *l,
532 const struct compat_50_netbsd32__lwp_park_args *uap, register_t *retval)
533{
534 /* {
535 syscallarg(const netbsd32_timespec50p) ts;
536 syscallarg(lwpid_t) unpark;
537 syscallarg(netbsd32_voidp) hint;
538 syscallarg(netbsd32_voidp) unparkhint;
539 } */
540 struct timespec ts, *tsp;
541 struct netbsd32_timespec50 ts32;
542 int error;
543
544 if (SCARG_P32(uap, ts) == NULL)
545 tsp = NULL;
546 else {
547 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof ts32);
548 if (error != 0)
549 return error;
550 netbsd32_to_timespec50(&ts32, &ts);
551 tsp = &ts;
552 }
553
554 if (SCARG(uap, unpark) != 0) {
555 error = lwp_unpark(SCARG(uap, unpark),
556 SCARG_P32(uap, unparkhint));
557 if (error != 0)
558 return error;
559 }
560
561 return lwp_park(CLOCK_REALTIME, TIMER_ABSTIME, tsp,
562 SCARG_P32(uap, hint));
563}
564
565static int
566netbsd32_kevent_fetch_timeout(const void *src, void *dest, size_t length)
567{
568 struct netbsd32_timespec50 ts32;
569 int error;
570
571 KASSERT(length == sizeof(struct timespec50));
572
573 error = copyin(src, &ts32, sizeof(ts32));
574 if (error)
575 return error;
576 netbsd32_to_timespec50(&ts32, (struct timespec *)dest);
577 return 0;
578}
579
580static int
581netbsd32_kevent_fetch_changes(void *ctx, const struct kevent *changelist,
582 struct kevent *changes, size_t index, int n)
583{
584 const struct netbsd32_kevent *src =
585 (const struct netbsd32_kevent *)changelist;
586 struct netbsd32_kevent *kev32, *changes32 = ctx;
587 int error, i;
588
589 error = copyin(src + index, changes32, n * sizeof(*changes32));
590 if (error)
591 return error;
592 for (i = 0, kev32 = changes32; i < n; i++, kev32++, changes++)
593 netbsd32_to_kevent(kev32, changes);
594 return 0;
595}
596
597static int
598netbsd32_kevent_put_events(void *ctx, struct kevent *events,
599 struct kevent *eventlist, size_t index, int n)
600{
601 struct netbsd32_kevent *kev32, *events32 = ctx;
602 int i;
603
604 for (i = 0, kev32 = events32; i < n; i++, kev32++, events++)
605 netbsd32_from_kevent(events, kev32);
606 kev32 = (struct netbsd32_kevent *)eventlist;
607 return copyout(events32, kev32, n * sizeof(*events32));
608}
609
610int
611compat_50_netbsd32_kevent(struct lwp *l,
612 const struct compat_50_netbsd32_kevent_args *uap, register_t *retval)
613{
614 /* {
615 syscallarg(int) fd;
616 syscallarg(netbsd32_keventp_t) changelist;
617 syscallarg(netbsd32_size_t) nchanges;
618 syscallarg(netbsd32_keventp_t) eventlist;
619 syscallarg(netbsd32_size_t) nevents;
620 syscallarg(netbsd32_timespec50p_t) timeout;
621 } */
622 int error;
623 size_t maxalloc, nchanges, nevents;
624 struct kevent_ops netbsd32_kevent_ops = {
625 .keo_fetch_timeout = netbsd32_kevent_fetch_timeout,
626 .keo_fetch_changes = netbsd32_kevent_fetch_changes,
627 .keo_put_events = netbsd32_kevent_put_events,
628 };
629
630 nchanges = SCARG(uap, nchanges);
631 nevents = SCARG(uap, nevents);
632 maxalloc = KQ_NEVENTS;
633
634 netbsd32_kevent_ops.keo_private =
635 kmem_alloc(maxalloc * sizeof(struct netbsd32_kevent), KM_SLEEP);
636
637 error = kevent1(retval, SCARG(uap, fd),
638 NETBSD32PTR64(SCARG(uap, changelist)), nchanges,
639 NETBSD32PTR64(SCARG(uap, eventlist)), nevents,
640 NETBSD32PTR64(SCARG(uap, timeout)), &netbsd32_kevent_ops);
641
642 kmem_free(netbsd32_kevent_ops.keo_private,
643 maxalloc * sizeof(struct netbsd32_kevent));
644 return error;
645}
646
647int
648compat_50_netbsd32_pselect(struct lwp *l,
649 const struct compat_50_netbsd32_pselect_args *uap, register_t *retval)
650{
651 /* {
652 syscallarg(int) nd;
653 syscallarg(netbsd32_fd_setp_t) in;
654 syscallarg(netbsd32_fd_setp_t) ou;
655 syscallarg(netbsd32_fd_setp_t) ex;
656 syscallarg(const netbsd32_timespec50p_t) ts;
657 syscallarg(const netbsd32_sigsetp_t) mask;
658 } */
659 int error;
660 struct netbsd32_timespec50 ts32;
661 struct timespec ats, *ts = NULL;
662 sigset_t amask, *mask = NULL;
663
664 if (SCARG_P32(uap, ts)) {
665 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof(ts32));
666 if (error != 0)
667 return error;
668 netbsd32_to_timespec50(&ts32, &ats);
669 ts = &ats;
670 }
671 if (SCARG_P32(uap, mask)) {
672 error = copyin(SCARG_P32(uap, mask), &amask, sizeof(amask));
673 if (error != 0)
674 return error;
675 mask = &amask;
676 }
677
678 return selcommon(retval, SCARG(uap, nd), SCARG_P32(uap, in),
679 SCARG_P32(uap, ou), SCARG_P32(uap, ex), ts, mask);
680}
681
682int
683compat_50_netbsd32_pollts(struct lwp *l,
684 const struct compat_50_netbsd32_pollts_args *uap, register_t *retval)
685{
686 /* {
687 syscallarg(struct netbsd32_pollfdp_t) fds;
688 syscallarg(u_int) nfds;
689 syscallarg(const netbsd32_timespec50p_t) ts;
690 syscallarg(const netbsd32_sigsetp_t) mask;
691 } */
692 int error;
693 struct netbsd32_timespec50 ts32;
694 struct timespec ats, *ts = NULL;
695 sigset_t amask, *mask = NULL;
696
697 if (SCARG_P32(uap, ts)) {
698 error = copyin(SCARG_P32(uap, ts), &ts32, sizeof(ts32));
699 if (error != 0)
700 return error;
701 netbsd32_to_timespec50(&ts32, &ats);
702 ts = &ats;
703 }
704 if (NETBSD32PTR64( SCARG(uap, mask))) {
705 error = copyin(SCARG_P32(uap, mask), &amask, sizeof(amask));
706 if (error != 0)
707 return error;
708 mask = &amask;
709 }
710
711 return pollcommon(retval, SCARG_P32(uap, fds),
712 SCARG(uap, nfds), ts, mask);
713}
714
715int
716compat_50_netbsd32___stat30(struct lwp *l,
717 const struct compat_50_netbsd32___stat30_args *uap, register_t *retval)
718{
719 /* {
720 syscallarg(const netbsd32_charp) path;
721 syscallarg(netbsd32_stat50p_t) ub;
722 } */
723 struct netbsd32_stat50 sb32;
724 struct stat sb;
725 int error;
726 const char *path;
727
728 path = SCARG_P32(uap, path);
729
730 error = do_sys_stat(path, FOLLOW, &sb);
731 if (error)
732 return error;
733 netbsd32_from___stat50(&sb, &sb32);
734 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
735 return error;
736}
737
738int
739compat_50_netbsd32___fstat30(struct lwp *l,
740 const struct compat_50_netbsd32___fstat30_args *uap, register_t *retval)
741{
742 /* {
743 syscallarg(int) fd;
744 syscallarg(netbsd32_stat50p_t) sb;
745 } */
746 struct netbsd32_stat50 sb32;
747 struct stat ub;
748 int error;
749
750 error = do_sys_fstat(SCARG(uap, fd), &ub);
751 if (error == 0) {
752 netbsd32_from___stat50(&ub, &sb32);
753 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32));
754 }
755 return error;
756}
757
758int
759compat_50_netbsd32___lstat30(struct lwp *l,
760 const struct compat_50_netbsd32___lstat30_args *uap, register_t *retval)
761{
762 /* {
763 syscallarg(const netbsd32_charp) path;
764 syscallarg(netbsd32_stat50p_t) ub;
765 } */
766 struct netbsd32_stat50 sb32;
767 struct stat sb;
768 int error;
769 const char *path;
770
771 path = SCARG_P32(uap, path);
772
773 error = do_sys_stat(path, NOFOLLOW, &sb);
774 if (error)
775 return error;
776 netbsd32_from___stat50(&sb, &sb32);
777 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
778 return error;
779}
780
781int
782compat_50_netbsd32___fhstat40(struct lwp *l, const struct compat_50_netbsd32___fhstat40_args *uap, register_t *retval)
783{
784 /* {
785 syscallarg(const netbsd32_pointer_t) fhp;
786 syscallarg(netbsd32_size_t) fh_size;
787 syscallarg(netbsd32_stat50p_t) sb;
788 } */
789 struct stat sb;
790 struct netbsd32_stat50 sb32;
791 int error;
792
793 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb);
794 if (error != 0) {
795 netbsd32_from___stat50(&sb, &sb32);
796 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb));
797 }
798 return error;
799}
800
801int
802compat_50_netbsd32_wait4(struct lwp *l, const struct compat_50_netbsd32_wait4_args *uap, register_t *retval)
803{
804 /* {
805 syscallarg(int) pid;
806 syscallarg(netbsd32_intp) status;
807 syscallarg(int) options;
808 syscallarg(netbsd32_rusage50p_t) rusage;
809 } */
810 int error, status, pid = SCARG(uap, pid);
811 struct netbsd32_rusage50 ru32;
812 struct rusage ru;
813
814 error = do_sys_wait(&pid, &status, SCARG(uap, options),
815 SCARG_P32(uap, rusage) != NULL ? &ru : NULL);
816
817 retval[0] = pid;
818 if (pid == 0)
819 return error;
820
821 if (SCARG_P32(uap, rusage)) {
822 netbsd32_from_rusage50(&ru, &ru32);
823 error = copyout(&ru32, SCARG_P32(uap, rusage), sizeof(ru32));
824 }
825
826 if (error == 0 && SCARG_P32(uap, status))
827 error = copyout(&status, SCARG_P32(uap, status), sizeof(status));
828
829 return error;
830}
831
832
833int
834compat_50_netbsd32_getrusage(struct lwp *l, const struct compat_50_netbsd32_getrusage_args *uap, register_t *retval)
835{
836 /* {
837 syscallarg(int) who;
838 syscallarg(netbsd32_rusage50p_t) rusage;
839 } */
840 int error;
841 struct proc *p = l->l_proc;
842 struct rusage ru;
843 struct netbsd32_rusage50 ru32;
844
845 error = getrusage1(p, SCARG(uap, who), &ru);
846 if (error != 0)
847 return error;
848
849 netbsd32_from_rusage50(&ru, &ru32);
850 return copyout(&ru32, SCARG_P32(uap, rusage), sizeof(ru32));
851}
852
853int
854compat_50_netbsd32_setitimer(struct lwp *l,
855 const struct compat_50_netbsd32_setitimer_args *uap, register_t *retval)
856{
857 /* {
858 syscallarg(int) which;
859 syscallarg(const netbsd32_itimerval50p_t) itv;
860 syscallarg(netbsd32_itimerval50p_t) oitv;
861 } */
862 struct proc *p = l->l_proc;
863 struct netbsd32_itimerval50 s32it, *itv32;
864 int which = SCARG(uap, which);
865 struct compat_50_netbsd32_getitimer_args getargs;
866 struct itimerval aitv;
867 int error;
868
869 if ((u_int)which > ITIMER_PROF)
870 return (EINVAL);
871 itv32 = SCARG_P32(uap, itv);
872 if (itv32) {
873 if ((error = copyin(itv32, &s32it, sizeof(s32it))))
874 return (error);
875 netbsd32_to_itimerval50(&s32it, &aitv);
876 }
877 if (SCARG_P32(uap, oitv) != 0) {
878 SCARG(&getargs, which) = which;
879 SCARG(&getargs, itv) = SCARG(uap, oitv);
880 if ((error = compat_50_netbsd32_getitimer(l, &getargs, retval)) != 0)
881 return (error);
882 }
883 if (itv32 == 0)
884 return 0;
885
886 return dosetitimer(p, which, &aitv);
887}
888
889int
890compat_50_netbsd32_getitimer(struct lwp *l, const struct compat_50_netbsd32_getitimer_args *uap, register_t *retval)
891{
892 /* {
893 syscallarg(int) which;
894 syscallarg(netbsd32_itimerval50p_t) itv;
895 } */
896 struct proc *p = l->l_proc;
897 struct netbsd32_itimerval50 s32it;
898 struct itimerval aitv;
899 int error;
900
901 error = dogetitimer(p, SCARG(uap, which), &aitv);
902 if (error)
903 return error;
904
905 netbsd32_from_itimerval50(&aitv, &s32it);
906 return copyout(&s32it, SCARG_P32(uap, itv), sizeof(s32it));
907}
908
909int
910compat_50_netbsd32_quotactl(struct lwp *l, const struct compat_50_netbsd32_quotactl_args *uap, register_t *retval)
911{
912 /* {
913 syscallarg(const netbsd32_charp) path;
914 syscallarg(int) cmd;
915 syscallarg(int) uid;
916 syscallarg(netbsd32_voidp) arg;
917 } */
918 struct compat_50_sys_quotactl_args ua;
919
920 NETBSD32TOP_UAP(path, const char);
921 NETBSD32TO64_UAP(cmd);
922 NETBSD32TO64_UAP(uid);
923 NETBSD32TOP_UAP(arg, void *);
924 return (compat_50_sys_quotactl(l, &ua, retval));
925}
926
927#endif /* COMPAT_50 */
928