netbsd32_netbsd.c revision 1.5 1 /* $NetBSD: netbsd32_netbsd.c,v 1.5 1998/09/11 00:01:57 eeh Exp $ */
2
3 /*
4 * Copyright (c) 1998 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 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include "opt_ktrace.h"
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/ipc.h>
36 #include <sys/msg.h>
37 #include <sys/sem.h>
38 #include <sys/shm.h>
39 #include <sys/malloc.h>
40 #include <sys/mount.h>
41 #include <sys/socket.h>
42 #include <sys/sockio.h>
43 #include <sys/stat.h>
44 #include <sys/time.h>
45 #include <sys/timex.h>
46 #include <sys/signalvar.h>
47
48 #include <vm/vm.h>
49 #include <sys/syscallargs.h>
50
51 #include <net/if.h>
52
53 #include <compat/sparc32/sparc32.h>
54 #include <compat/sparc32/sparc32_syscallargs.h>
55
56 #include <machine/frame.h>
57
58 static __inline void sparc32_from_timeval __P((struct timeval *, struct sparc32_timeval *));
59 static __inline void sparc32_to_timeval __P((struct sparc32_timeval *, struct timeval *));
60 static __inline void sparc32_from_itimerval __P((struct itimerval *, struct sparc32_itimerval *));
61 static __inline void sparc32_to_itimerval __P((struct sparc32_itimerval *, struct itimerval *));
62 static __inline void sparc32_to_timespec __P((struct sparc32_timespec *, struct timespec *));
63 static __inline void sparc32_from_timespec __P((struct timespec *, struct sparc32_timespec *));
64 static __inline void sparc32_from_rusage __P((struct rusage *, struct sparc32_rusage *));
65 static __inline void sparc32_to_rusage __P((struct sparc32_rusage *, struct rusage *));
66 static __inline void sparc32_to_iovec __P((struct sparc32_iovec *, struct iovec *, int));
67 static __inline void sparc32_to_msghdr __P((struct sparc32_msghdr *, struct msghdr *));
68 static __inline void sparc32_from_statfs __P((struct statfs *, struct sparc32_statfs *));
69 static __inline void sparc32_from_timex __P((struct timex *, struct sparc32_timex *));
70 static __inline void sparc32_to_timex __P((struct sparc32_timex *, struct timex *));
71 static __inline void sparc32_from___stat13 __P((struct stat *, struct sparc32_stat *));
72 static __inline void sparc32_to_ipc_perm __P((struct sparc32_ipc_perm *, struct ipc_perm *));
73 static __inline void sparc32_from_ipc_perm __P((struct ipc_perm *, struct sparc32_ipc_perm *));
74 static __inline void sparc32_to_msg __P((struct sparc32_msg *, struct msg *));
75 static __inline void sparc32_from_msg __P((struct msg *, struct sparc32_msg *));
76 static __inline void sparc32_to_msqid_ds __P((struct sparc32_msqid_ds *, struct msqid_ds *));
77 static __inline void sparc32_from_msqid_ds __P((struct msqid_ds *, struct sparc32_msqid_ds *));
78 static __inline void sparc32_to_shmid_ds __P((struct sparc32_shmid_ds *, struct shmid_ds *));
79 static __inline void sparc32_from_shmid_ds __P((struct shmid_ds *, struct sparc32_shmid_ds *));
80 static __inline void sparc32_to_semid_ds __P((struct sparc32_semid_ds *, struct semid_ds *));
81 static __inline void sparc32_from_semid_ds __P((struct semid_ds *, struct sparc32_semid_ds *));
82
83 /* converters for structures that we need */
84 static __inline void
85 sparc32_from_timeval(tv, tv32)
86 struct timeval *tv;
87 struct sparc32_timeval *tv32;
88 {
89
90 tv32->tv_sec = (sparc32_long)tv->tv_sec;
91 tv32->tv_usec = (sparc32_long)tv->tv_usec;
92 }
93
94 static __inline void
95 sparc32_to_timeval(tv32, tv)
96 struct sparc32_timeval *tv32;
97 struct timeval *tv;
98 {
99
100 tv->tv_sec = (long)tv32->tv_sec;
101 tv->tv_usec = (long)tv32->tv_usec;
102 }
103
104 static __inline void
105 sparc32_from_itimerval(itv, itv32)
106 struct itimerval *itv;
107 struct sparc32_itimerval *itv32;
108 {
109
110 sparc32_from_timeval(&itv->it_interval, &itv32->it_interval);
111 sparc32_from_timeval(&itv->it_value, &itv32->it_value);
112 }
113
114 static __inline void
115 sparc32_to_itimerval(itv32, itv)
116 struct sparc32_itimerval *itv32;
117 struct itimerval *itv;
118 {
119
120 sparc32_to_timeval(&itv->it_interval, &itv32->it_interval);
121 sparc32_to_timeval(&itv->it_value, &itv32->it_value);
122 }
123
124 static __inline void
125 sparc32_to_timespec(s32p, p)
126 struct sparc32_timespec *s32p;
127 struct timespec *p;
128 {
129
130 p->tv_sec = s32p->tv_sec;
131 p->tv_nsec = (long)s32p->tv_nsec;
132 }
133
134 static __inline void
135 sparc32_from_timespec(p, s32p)
136 struct timespec *p;
137 struct sparc32_timespec *s32p;
138 {
139
140 s32p->tv_sec = p->tv_sec;
141 s32p->tv_nsec = (sparc32_long)p->tv_nsec;
142 }
143
144 static __inline void
145 sparc32_from_rusage(rup, ru32p)
146 struct rusage *rup;
147 struct sparc32_rusage *ru32p;
148 {
149
150 sparc32_from_timeval(&rup->ru_utime, &ru32p->ru_utime);
151 sparc32_from_timeval(&rup->ru_stime, &ru32p->ru_stime);
152 #define C(var) ru32p->var = (sparc32_long)rup->var
153 C(ru_maxrss);
154 C(ru_ixrss);
155 C(ru_idrss);
156 C(ru_isrss);
157 C(ru_minflt);
158 C(ru_majflt);
159 C(ru_nswap);
160 C(ru_inblock);
161 C(ru_oublock);
162 C(ru_msgsnd);
163 C(ru_msgrcv);
164 C(ru_nsignals);
165 C(ru_nvcsw);
166 C(ru_nivcsw);
167 #undef C
168 }
169
170 static __inline void
171 sparc32_to_rusage(ru32p, rup)
172 struct sparc32_rusage *ru32p;
173 struct rusage *rup;
174 {
175
176 sparc32_to_timeval(&ru32p->ru_utime, &rup->ru_utime);
177 sparc32_to_timeval(&ru32p->ru_stime, &rup->ru_stime);
178 #define C(var) rup->var = (long)ru32p->var
179 C(ru_maxrss);
180 C(ru_ixrss);
181 C(ru_idrss);
182 C(ru_isrss);
183 C(ru_minflt);
184 C(ru_majflt);
185 C(ru_nswap);
186 C(ru_inblock);
187 C(ru_oublock);
188 C(ru_msgsnd);
189 C(ru_msgrcv);
190 C(ru_nsignals);
191 C(ru_nvcsw);
192 C(ru_nivcsw);
193 #undef C
194 }
195
196 static __inline void
197 sparc32_to_iovec(iov32p, iovp, len)
198 struct sparc32_iovec *iov32p;
199 struct iovec *iovp;
200 int len;
201 {
202 int i;
203
204 for (i = 0; i < len; i++, iovp++, iov32p++) {
205 iovp->iov_base = (void *)(u_long)iov32p->iov_base;
206 iovp->iov_len = (size_t)iov32p->iov_len;
207 }
208 }
209
210 /* assumes that mhp's msg_iov has been allocated */
211 static __inline void
212 sparc32_to_msghdr(mhp32, mhp)
213 struct sparc32_msghdr *mhp32;
214 struct msghdr *mhp;
215 {
216
217 mhp->msg_name = (caddr_t)(u_long)mhp32->msg_name;
218 mhp->msg_namelen = mhp32->msg_namelen;
219 mhp->msg_iovlen = (size_t)mhp32->msg_iovlen;
220 mhp->msg_control = (caddr_t)(u_long)mhp32->msg_control;
221 mhp->msg_controllen = mhp32->msg_controllen;
222 mhp->msg_flags = mhp32->msg_flags;
223 sparc32_to_iovec(mhp32->msg_iov, mhp->msg_iov, mhp->msg_iovlen);
224 }
225
226 static __inline void
227 sparc32_from_statfs(sbp, sb32p)
228 struct statfs *sbp;
229 struct sparc32_statfs *sb32p;
230 {
231
232 sb32p->f_type = sbp->f_type;
233 sb32p->f_flags = sbp->f_flags;
234 sb32p->f_bsize = (sparc32_long)sbp->f_bsize;
235 sb32p->f_iosize = (sparc32_long)sbp->f_iosize;
236 sb32p->f_blocks = (sparc32_long)sbp->f_blocks;
237 sb32p->f_bfree = (sparc32_long)sbp->f_bfree;
238 sb32p->f_bavail = (sparc32_long)sbp->f_bavail;
239 sb32p->f_files = (sparc32_long)sbp->f_files;
240 sb32p->f_ffree = (sparc32_long)sbp->f_ffree;
241 sb32p->f_fsid = sbp->f_fsid;
242 sb32p->f_owner = sbp->f_owner;
243 strncpy(sbp->f_fstypename, sb32p->f_fstypename, MFSNAMELEN);
244 strncpy(sbp->f_fstypename, sb32p->f_fstypename, MNAMELEN);
245 strncpy(sbp->f_fstypename, sb32p->f_mntfromname, MNAMELEN);
246 }
247
248 static __inline void
249 sparc32_from_timex(txp, tx32p)
250 struct timex *txp;
251 struct sparc32_timex *tx32p;
252 {
253
254 tx32p->modes = txp->modes;
255 tx32p->offset = (sparc32_long)txp->offset;
256 tx32p->freq = (sparc32_long)txp->freq;
257 tx32p->maxerror = (sparc32_long)txp->maxerror;
258 tx32p->esterror = (sparc32_long)txp->esterror;
259 tx32p->status = txp->status;
260 tx32p->constant = (sparc32_long)txp->constant;
261 tx32p->precision = (sparc32_long)txp->precision;
262 tx32p->tolerance = (sparc32_long)txp->tolerance;
263 tx32p->ppsfreq = (sparc32_long)txp->ppsfreq;
264 tx32p->jitter = (sparc32_long)txp->jitter;
265 tx32p->shift = txp->shift;
266 tx32p->stabil = (sparc32_long)txp->stabil;
267 tx32p->jitcnt = (sparc32_long)txp->jitcnt;
268 tx32p->calcnt = (sparc32_long)txp->calcnt;
269 tx32p->errcnt = (sparc32_long)txp->errcnt;
270 tx32p->stbcnt = (sparc32_long)txp->stbcnt;
271 }
272
273 static __inline void
274 sparc32_to_timex(tx32p, txp)
275 struct sparc32_timex *tx32p;
276 struct timex *txp;
277 {
278
279 txp->modes = tx32p->modes;
280 txp->offset = (long)tx32p->offset;
281 txp->freq = (long)tx32p->freq;
282 txp->maxerror = (long)tx32p->maxerror;
283 txp->esterror = (long)tx32p->esterror;
284 txp->status = tx32p->status;
285 txp->constant = (long)tx32p->constant;
286 txp->precision = (long)tx32p->precision;
287 txp->tolerance = (long)tx32p->tolerance;
288 txp->ppsfreq = (long)tx32p->ppsfreq;
289 txp->jitter = (long)tx32p->jitter;
290 txp->shift = tx32p->shift;
291 txp->stabil = (long)tx32p->stabil;
292 txp->jitcnt = (long)tx32p->jitcnt;
293 txp->calcnt = (long)tx32p->calcnt;
294 txp->errcnt = (long)tx32p->errcnt;
295 txp->stbcnt = (long)tx32p->stbcnt;
296 }
297
298 static __inline void
299 sparc32_from___stat13(sbp, sb32p)
300 struct stat *sbp;
301 struct sparc32_stat *sb32p;
302 {
303 sb32p->st_dev = sbp->st_dev;
304 sb32p->st_ino = sbp->st_ino;
305 sb32p->st_mode = sbp->st_mode;
306 sb32p->st_nlink = sbp->st_nlink;
307 sb32p->st_uid = sbp->st_uid;
308 sb32p->st_gid = sbp->st_gid;
309 sb32p->st_rdev = sbp->st_rdev;
310 if (sbp->st_size < (quad_t)1 << 32)
311 sb32p->st_size = sbp->st_size;
312 else
313 sb32p->st_size = -2;
314 sb32p->st_atimespec.tv_sec = sbp->st_atimespec.tv_sec;
315 sb32p->st_atimespec.tv_nsec = (sparc32_long)sbp->st_atimespec.tv_nsec;
316 sb32p->st_mtimespec.tv_sec = sbp->st_mtimespec.tv_sec;
317 sb32p->st_mtimespec.tv_nsec = (sparc32_long)sbp->st_mtimespec.tv_nsec;
318 sb32p->st_ctimespec.tv_sec = sbp->st_ctimespec.tv_sec;
319 sb32p->st_ctimespec.tv_nsec = (sparc32_long)sbp->st_ctimespec.tv_nsec;
320 sb32p->st_blksize = sbp->st_blksize;
321 sb32p->st_blocks = sbp->st_blocks;
322 sb32p->st_flags = sbp->st_flags;
323 sb32p->st_gen = sbp->st_gen;
324 }
325
326 static __inline void
327 sparc32_to_ipc_perm(ip32p, ipp)
328 struct sparc32_ipc_perm *ip32p;
329 struct ipc_perm *ipp;
330 {
331
332 ipp->cuid = ip32p->cuid;
333 ipp->cgid = ip32p->cgid;
334 ipp->uid = ip32p->uid;
335 ipp->gid = ip32p->gid;
336 ipp->mode = ip32p->mode;
337 ipp->seq = ip32p->seq;
338 ipp->key = (key_t)ip32p->key;
339 }
340
341 static __inline void
342 sparc32_from_ipc_perm(ipp, ip32p)
343 struct ipc_perm *ipp;
344 struct sparc32_ipc_perm *ip32p;
345 {
346
347 ip32p->cuid = ipp->cuid;
348 ip32p->cgid = ipp->cgid;
349 ip32p->uid = ipp->uid;
350 ip32p->gid = ipp->gid;
351 ip32p->mode = ipp->mode;
352 ip32p->seq = ipp->seq;
353 ip32p->key = (sparc32_key_t)ipp->key;
354 }
355
356 static __inline void
357 sparc32_to_msg(m32p, mp)
358 struct sparc32_msg *m32p;
359 struct msg *mp;
360 {
361
362 mp->msg_next = (struct msg *)(u_long)m32p->msg_next;
363 mp->msg_type = (long)m32p->msg_type;
364 mp->msg_ts = m32p->msg_ts;
365 mp->msg_spot = m32p->msg_spot;
366 }
367
368 static __inline void
369 sparc32_from_msg(mp, m32p)
370 struct msg *mp;
371 struct sparc32_msg *m32p;
372 {
373
374 m32p->msg_next = (sparc32_msgp_t)(u_long)mp->msg_next;
375 m32p->msg_type = (sparc32_long)mp->msg_type;
376 m32p->msg_ts = mp->msg_ts;
377 m32p->msg_spot = mp->msg_spot;
378 }
379
380 static __inline void
381 sparc32_to_msqid_ds(ds32p, dsp)
382 struct sparc32_msqid_ds *ds32p;
383 struct msqid_ds *dsp;
384 {
385
386 sparc32_to_ipc_perm(&ds32p->msg_perm, &dsp->msg_perm);
387 sparc32_to_msg(&ds32p->msg_first, &dsp->msg_first);
388 sparc32_to_msg(&ds32p->msg_last, &dsp->msg_last);
389 dsp->msg_cbytes = (u_long)ds32p->msg_cbytes;
390 dsp->msg_qnum = (u_long)ds32p->msg_qnum;
391 dsp->msg_qbytes = (u_long)ds32p->msg_qbytes;
392 dsp->msg_lspid = ds32p->msg_lspid;
393 dsp->msg_lrpid = ds32p->msg_lrpid;
394 dsp->msg_rtime = (time_t)ds32p->msg_rtime;
395 dsp->msg_stime = (time_t)ds32p->msg_stime;
396 dsp->msg_ctime = (time_t)ds32p->msg_ctime;
397 }
398
399 static __inline void
400 sparc32_from_msqid_ds(dsp, ds32p)
401 struct msqid_ds *dsp;
402 struct sparc32_msqid_ds *ds32p;
403 {
404
405 sparc32_from_ipc_perm(&dsp->msg_perm, &ds32p->msg_perm);
406 sparc32_from_msg(&dsp->msg_first, &ds32p->msg_first);
407 sparc32_from_msg(&dsp->msg_last, &ds32p->msg_last);
408 ds32p->msg_cbytes = (sparc32_u_long)dsp->msg_cbytes;
409 ds32p->msg_qnum = (sparc32_u_long)dsp->msg_qnum;
410 ds32p->msg_qbytes = (sparc32_u_long)dsp->msg_qbytes;
411 ds32p->msg_lspid = dsp->msg_lspid;
412 ds32p->msg_lrpid = dsp->msg_lrpid;
413 ds32p->msg_rtime = dsp->msg_rtime;
414 ds32p->msg_stime = dsp->msg_stime;
415 ds32p->msg_ctime = dsp->msg_ctime;
416 }
417
418 static __inline void
419 sparc32_to_shmid_ds(ds32p, dsp)
420 struct sparc32_shmid_ds *ds32p;
421 struct shmid_ds *dsp;
422 {
423
424 sparc32_to_ipc_perm(&ds32p->shm_perm, &dsp->shm_perm);
425 dsp->shm_segsz = ds32p->shm_segsz;
426 dsp->shm_lpid = ds32p->shm_lpid;
427 dsp->shm_cpid = ds32p->shm_cpid;
428 dsp->shm_nattch = ds32p->shm_nattch;
429 dsp->shm_atime = (long)ds32p->shm_atime;
430 dsp->shm_dtime = (long)ds32p->shm_dtime;
431 dsp->shm_ctime = (long)ds32p->shm_ctime;
432 dsp->shm_internal = (void *)(u_long)ds32p->shm_internal;
433 }
434
435 static __inline void
436 sparc32_from_shmid_ds(dsp, ds32p)
437 struct shmid_ds *dsp;
438 struct sparc32_shmid_ds *ds32p;
439 {
440
441 sparc32_from_ipc_perm(&dsp->shm_perm, &ds32p->shm_perm);
442 ds32p->shm_segsz = dsp->shm_segsz;
443 ds32p->shm_lpid = dsp->shm_lpid;
444 ds32p->shm_cpid = dsp->shm_cpid;
445 ds32p->shm_nattch = dsp->shm_nattch;
446 ds32p->shm_atime = (sparc32_long)dsp->shm_atime;
447 ds32p->shm_dtime = (sparc32_long)dsp->shm_dtime;
448 ds32p->shm_ctime = (sparc32_long)dsp->shm_ctime;
449 ds32p->shm_internal = (sparc32_voidp)(u_long)dsp->shm_internal;
450 }
451
452 static __inline void
453 sparc32_to_semid_ds(s32dsp, dsp)
454 struct sparc32_semid_ds *s32dsp;
455 struct semid_ds *dsp;
456 {
457
458 sparc32_from_ipc_perm(&dsp->sem_perm, &s32dsp->sem_perm);
459 dsp->sem_base = (struct sem *)(u_long)s32dsp->sem_base;
460 dsp->sem_nsems = s32dsp->sem_nsems;
461 dsp->sem_otime = s32dsp->sem_otime;
462 dsp->sem_ctime = s32dsp->sem_ctime;
463 }
464
465 static __inline void
466 sparc32_from_semid_ds(dsp, s32dsp)
467 struct semid_ds *dsp;
468 struct sparc32_semid_ds *s32dsp;
469 {
470
471 sparc32_to_ipc_perm(&s32dsp->sem_perm, &dsp->sem_perm);
472 s32dsp->sem_base = (sparc32_semp_t)(u_long)dsp->sem_base;
473 s32dsp->sem_nsems = dsp->sem_nsems;
474 s32dsp->sem_otime = dsp->sem_otime;
475 s32dsp->sem_ctime = dsp->sem_ctime;
476 }
477
478 /*
479 * below are all the standard NetBSD system calls, in the 32bit
480 * environment, witht he necessary conversions to 64bit before
481 * calling the real syscall.
482 */
483
484 int
485 compat_sparc32_read(p, v, retval)
486 struct proc *p;
487 void *v;
488 register_t *retval;
489 {
490 struct compat_sparc32_read_args /* {
491 syscallarg(int) fd;
492 syscallarg(sparc32_voidp) buf;
493 syscallarg(sparc32_size_t) nbyte;
494 } */ *uap = v;
495 struct sys_read_args ua;
496 ssize_t rt;
497 int error;
498
499 SPARC32TO64_UAP(fd);
500 SPARC32TOP_UAP(buf, void *);
501 SPARC32TOX_UAP(nbyte, size_t);
502 error = sys_read(p, &ua, (register_t *)&rt);
503 *(sparc32_ssize_t *)retval = rt;
504
505 return (error);
506 }
507
508 int
509 compat_sparc32_write(p, v, retval)
510 struct proc *p;
511 void *v;
512 register_t *retval;
513 {
514 struct compat_sparc32_write_args /* {
515 syscallarg(int) fd;
516 syscallarg(const sparc32_voidp) buf;
517 syscallarg(sparc32_size_t) nbyte;
518 } */ *uap = v;
519 struct sys_write_args ua;
520 ssize_t rt;
521 int error;
522
523 SPARC32TO64_UAP(fd);
524 SPARC32TOP_UAP(buf, void *);
525 SPARC32TOX_UAP(nbyte, size_t);
526 error = sys_write(p, &ua, (register_t *)&rt);
527 *(sparc32_ssize_t *)retval = rt;
528
529 return (error);
530 }
531
532 int
533 compat_sparc32_open(p, v, retval)
534 struct proc *p;
535 void *v;
536 register_t *retval;
537 {
538 struct compat_sparc32_open_args /* {
539 syscallarg(const sparc32_charp) path;
540 syscallarg(int) flags;
541 syscallarg(mode_t) mode;
542 } */ *uap = v;
543 struct sys_open_args ua;
544 caddr_t sg;
545
546 SPARC32TOP_UAP(path, const char);
547 SPARC32TO64_UAP(flags);
548 SPARC32TO64_UAP(mode);
549 sg = stackgap_init(p->p_emul);
550 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
551
552 return (sys_open(p, &ua, retval));
553 }
554
555 int
556 compat_sparc32_wait4(p, v, retval)
557 struct proc *p;
558 void *v;
559 register_t *retval;
560 {
561 struct compat_sparc32_wait4_args /* {
562 syscallarg(int) pid;
563 syscallarg(sparc32_intp) status;
564 syscallarg(int) options;
565 syscallarg(sparc32_rusagep_t) rusage;
566 } */ *uap = v;
567 struct sys_wait4_args ua;
568 struct rusage ru;
569 struct sparc32_rusage *ru32p;
570 struct sparc32_rusage ru32;
571 int error;
572
573 SPARC32TO64_UAP(pid);
574 SPARC32TOP_UAP(status, int);
575 SPARC32TO64_UAP(options);
576 ru32p = (struct sparc32_rusage *)(u_long)SCARG(uap, rusage);
577 if (ru32p) {
578 if (copyin(ru32p, &ru32, sizeof(ru32)))
579 return (EFAULT);
580 SCARG(&ua, rusage) = &ru;
581 sparc32_to_rusage(&ru32, &ru);
582 } else
583 SCARG(&ua, rusage) = NULL;
584
585 error = sys_wait4(p, &ua, retval);
586 if (ru32p) {
587 sparc32_from_rusage(&ru, &ru32);
588 if (copyout(&ru32, ru32p, sizeof(ru32)))
589 error = EFAULT;
590 }
591 return (error);
592 }
593
594 int
595 compat_sparc32_link(p, v, retval)
596 struct proc *p;
597 void *v;
598 register_t *retval;
599 {
600 struct compat_sparc32_link_args /* {
601 syscallarg(const sparc32_charp) path;
602 syscallarg(const sparc32_charp) link;
603 } */ *uap = v;
604 struct sys_link_args ua;
605
606 SPARC32TOP_UAP(path, const char);
607 SPARC32TOP_UAP(link, const char);
608 return (sys_link(p, &ua, retval));
609 }
610
611 int
612 compat_sparc32_unlink(p, v, retval)
613 struct proc *p;
614 void *v;
615 register_t *retval;
616 {
617 struct compat_sparc32_unlink_args /* {
618 syscallarg(const sparc32_charp) path;
619 } */ *uap = v;
620 struct sys_unlink_args ua;
621
622 SPARC32TOP_UAP(path, const char);
623
624 return (sys_unlink(p, &ua, retval));
625 }
626
627 int
628 compat_sparc32_chdir(p, v, retval)
629 struct proc *p;
630 void *v;
631 register_t *retval;
632 {
633 struct compat_sparc32_chdir_args /* {
634 syscallarg(const sparc32_charp) path;
635 } */ *uap = v;
636 struct sys_chdir_args ua;
637
638 SPARC32TOP_UAP(path, const char);
639
640 return (sys_chdir(p, &ua, retval));
641 }
642
643 int
644 compat_sparc32_mknod(p, v, retval)
645 struct proc *p;
646 void *v;
647 register_t *retval;
648 {
649 struct compat_sparc32_mknod_args /* {
650 syscallarg(const sparc32_charp) path;
651 syscallarg(mode_t) mode;
652 syscallarg(dev_t) dev;
653 } */ *uap = v;
654 struct sys_mknod_args ua;
655
656 SPARC32TOP_UAP(path, const char);
657 SPARC32TO64_UAP(dev);
658 SPARC32TO64_UAP(mode);
659
660 return (sys_mknod(p, &ua, retval));
661 }
662
663 int
664 compat_sparc32_chmod(p, v, retval)
665 struct proc *p;
666 void *v;
667 register_t *retval;
668 {
669 struct compat_sparc32_chmod_args /* {
670 syscallarg(const sparc32_charp) path;
671 syscallarg(mode_t) mode;
672 } */ *uap = v;
673 struct sys_chmod_args ua;
674
675 SPARC32TOP_UAP(path, const char);
676 SPARC32TO64_UAP(mode);
677
678 return (sys_chmod(p, &ua, retval));
679 }
680
681 int
682 compat_sparc32_chown(p, v, retval)
683 struct proc *p;
684 void *v;
685 register_t *retval;
686 {
687 struct compat_sparc32_chown_args /* {
688 syscallarg(const sparc32_charp) path;
689 syscallarg(uid_t) uid;
690 syscallarg(gid_t) gid;
691 } */ *uap = v;
692 struct sys_chown_args ua;
693
694 SPARC32TOP_UAP(path, const char);
695 SPARC32TO64_UAP(uid);
696 SPARC32TO64_UAP(gid);
697
698 return (sys_chown(p, &ua, retval));
699 }
700
701 int
702 compat_sparc32_break(p, v, retval)
703 struct proc *p;
704 void *v;
705 register_t *retval;
706 {
707 struct compat_sparc32_break_args /* {
708 syscallarg(sparc32_charp) nsize;
709 } */ *uap = v;
710 struct sys_obreak_args ua;
711
712 SCARG(&ua, nsize) = (char *)(u_long)SCARG(uap, nsize);
713 SPARC32TOP_UAP(nsize, char);
714 return (sys_obreak(p, &ua, retval));
715 }
716
717 int
718 compat_sparc32_getfsstat(p, v, retval)
719 struct proc *p;
720 void *v;
721 register_t *retval;
722 {
723 struct compat_sparc32_getfsstat_args /* {
724 syscallarg(sparc32_statfsp_t) buf;
725 syscallarg(sparc32_long) bufsize;
726 syscallarg(int) flags;
727 } */ *uap = v;
728 struct sys_getfsstat_args ua;
729 struct statfs sb;
730 struct sparc32_statfs *sb32p;
731 int error;
732
733 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
734 if (sb32p)
735 SCARG(&ua, buf) = &sb;
736 else
737 SCARG(&ua, buf) = NULL;
738 SPARC32TOX_UAP(bufsize, long);
739 SPARC32TO64_UAP(flags);
740 error = sys_getfsstat(p, &ua, retval);
741 if (error)
742 return (error);
743
744 if (sb32p) {
745 struct sparc32_statfs sb32;
746 sparc32_from_statfs(&sb, &sb32);
747 if (copyout(&sb32, sb32p, sizeof(sb32)))
748 return EFAULT;
749 }
750 return (0);
751 }
752
753 int
754 compat_sparc32_mount(p, v, retval)
755 struct proc *p;
756 void *v;
757 register_t *retval;
758 {
759 struct compat_sparc32_mount_args /* {
760 syscallarg(const sparc32_charp) type;
761 syscallarg(const sparc32_charp) path;
762 syscallarg(int) flags;
763 syscallarg(sparc32_voidp) data;
764 } */ *uap = v;
765 struct sys_mount_args ua;
766
767 SPARC32TOP_UAP(type, const char);
768 SPARC32TOP_UAP(path, const char);
769 SPARC32TO64_UAP(flags);
770 SPARC32TOP_UAP(data, void);
771 return (sys_mount(p, &ua, retval));
772 }
773
774 int
775 compat_sparc32_unmount(p, v, retval)
776 struct proc *p;
777 void *v;
778 register_t *retval;
779 {
780 struct compat_sparc32_unmount_args /* {
781 syscallarg(const sparc32_charp) path;
782 syscallarg(int) flags;
783 } */ *uap = v;
784 struct sys_unmount_args ua;
785
786 SPARC32TOP_UAP(path, const char);
787 SPARC32TO64_UAP(flags);
788 return (sys_unmount(p, &ua, retval));
789 }
790
791 int
792 compat_sparc32_ptrace(p, v, retval)
793 struct proc *p;
794 void *v;
795 register_t *retval;
796 {
797 struct compat_sparc32_ptrace_args /* {
798 syscallarg(int) req;
799 syscallarg(pid_t) pid;
800 syscallarg(sparc32_caddr_t) addr;
801 syscallarg(int) data;
802 } */ *uap = v;
803 struct sys_ptrace_args ua;
804
805 SPARC32TO64_UAP(req);
806 SPARC32TO64_UAP(pid);
807 SPARC32TOX64_UAP(addr, caddr_t);
808 SPARC32TO64_UAP(data);
809 return (sys_ptrace(p, &ua, retval));
810 }
811
812 int
813 compat_sparc32_recvmsg(p, v, retval)
814 struct proc *p;
815 void *v;
816 register_t *retval;
817 {
818 struct compat_sparc32_recvmsg_args /* {
819 syscallarg(int) s;
820 syscallarg(sparc32_msghdrp_t) msg;
821 syscallarg(int) flags;
822 } */ *uap = v;
823 struct sys_recvmsg_args ua;
824 struct msghdr mh;
825 struct msghdr *mhp = &mh;
826 struct sparc32_msghdr *mhp32, mh32;
827 ssize_t rt;
828 int error;
829
830 SPARC32TO64_UAP(s);
831 SPARC32TO64_UAP(flags);
832
833 SCARG(&ua, msg) = mhp;
834 mhp32 = (struct sparc32_msghdr *)(u_long)SCARG(uap, msg);
835 if (copyin(mhp32, &mh32, sizeof(mh32)))
836 return EFAULT;
837 /* sparc32_msghdr needs the iov pre-allocated */
838 MALLOC(mhp->msg_iov, struct iovec *,
839 sizeof(struct iovec) * mh32.msg_iovlen, M_TEMP, M_WAITOK);
840 sparc32_to_msghdr(&mh32, mhp);
841
842 error = sys_recvmsg(p, &ua, (register_t *)&rt);
843 FREE(mhp->msg_iov, M_TEMP);
844 *(sparc32_ssize_t *)retval = rt;
845 return (error);
846 }
847
848 int
849 compat_sparc32_sendmsg(p, v, retval)
850 struct proc *p;
851 void *v;
852 register_t *retval;
853 {
854 struct compat_sparc32_sendmsg_args /* {
855 syscallarg(int) s;
856 syscallarg(const sparc32_msghdrp_t) msg;
857 syscallarg(int) flags;
858 } */ *uap = v;
859 struct sys_sendmsg_args ua;
860 struct msghdr mh;
861 struct msghdr *mhp = &mh;
862 struct sparc32_msghdr *mhp32, mh32;
863 ssize_t rt;
864 int error;
865
866 SPARC32TO64_UAP(s);
867 SPARC32TO64_UAP(flags);
868
869 SCARG(&ua, msg) = mhp;
870 mhp32 = (struct sparc32_msghdr *)(u_long)SCARG(uap, msg);
871 if (copyin(mhp32, &mh32, sizeof(mh32)))
872 return EFAULT;
873 /* sparc32_msghdr needs the iov pre-allocated */
874 MALLOC(mhp->msg_iov, struct iovec *,
875 sizeof(struct iovec) * mh32.msg_iovlen, M_TEMP, M_WAITOK);
876 sparc32_to_msghdr(mhp32, mhp);
877
878 error = sys_sendmsg(p, &ua, (register_t *)&rt);
879 FREE(mhp->msg_iov, M_TEMP);
880 *(sparc32_ssize_t *)retval = rt;
881 return (error);
882 }
883
884 int
885 compat_sparc32_recvfrom(p, v, retval)
886 struct proc *p;
887 void *v;
888 register_t *retval;
889 {
890 struct compat_sparc32_recvfrom_args /* {
891 syscallarg(int) s;
892 syscallarg(sparc32_voidp) buf;
893 syscallarg(sparc32_size_t) len;
894 syscallarg(int) flags;
895 syscallarg(sparc32_sockaddrp_t) from;
896 syscallarg(sparc32_intp) fromlenaddr;
897 } */ *uap = v;
898 struct sys_recvfrom_args ua;
899 off_t rt;
900 int error;
901
902 SPARC32TO64_UAP(s);
903 SPARC32TOP_UAP(buf, void);
904 SPARC32TOX_UAP(len, size_t);
905 SPARC32TO64_UAP(flags);
906 SPARC32TOP_UAP(from, struct sockaddr);
907 SPARC32TOP_UAP(fromlenaddr, int);
908
909 error = sys_recvfrom(p, &ua, (register_t *)&rt);
910 *(sparc32_ssize_t *)retval = rt;
911 return (error);
912 }
913
914 int
915 compat_sparc32_sendto(p, v, retval)
916 struct proc *p;
917 void *v;
918 register_t *retval;
919 {
920 struct compat_sparc32_sendto_args /* {
921 syscallarg(int) s;
922 syscallarg(const sparc32_voidp) buf;
923 syscallarg(sparc32_size_t) len;
924 syscallarg(int) flags;
925 syscallarg(const sparc32_sockaddrp_t) to;
926 syscallarg(int) tolen;
927 } */ *uap = v;
928 struct sys_sendto_args ua;
929 off_t rt;
930 int error;
931
932 SPARC32TO64_UAP(s);
933 SPARC32TOP_UAP(buf, void);
934 SPARC32TOX_UAP(len, size_t);
935 SPARC32TO64_UAP(flags);
936 SPARC32TOP_UAP(to, struct sockaddr);
937 SPARC32TOX_UAP(tolen, int);
938
939 error = sys_sendto(p, &ua, (register_t *)&rt);
940 *(sparc32_ssize_t *)retval = rt;
941 return (error);
942 }
943
944 int
945 compat_sparc32_socketpair(p, v, retval)
946 struct proc *p;
947 void *v;
948 register_t *retval;
949 {
950 struct compat_sparc32_socketpair_args /* {
951 syscallarg(int) domain;
952 syscallarg(int) type;
953 syscallarg(int) protocol;
954 syscallarg(sparc32_intp) rsv;
955 } */ *uap = v;
956 struct sys_socketpair_args ua;
957
958 SPARC32TO64_UAP(domain);
959 SPARC32TO64_UAP(type);
960 SPARC32TO64_UAP(protocol);
961 SPARC32TOP_UAP(rsv, int);
962 return (sys_socketpair(p, &ua, retval));
963 }
964
965 int
966 compat_sparc32_accept(p, v, retval)
967 struct proc *p;
968 void *v;
969 register_t *retval;
970 {
971 struct compat_sparc32_accept_args /* {
972 syscallarg(int) s;
973 syscallarg(sparc32_sockaddrp_t) name;
974 syscallarg(sparc32_intp) anamelen;
975 } */ *uap = v;
976 struct sys_accept_args ua;
977
978 SPARC32TO64_UAP(s);
979 SPARC32TOP_UAP(name, struct sockaddr);
980 SPARC32TOP_UAP(anamelen, int);
981 return (sys_accept(p, &ua, retval));
982 }
983
984 int
985 compat_sparc32_getpeername(p, v, retval)
986 struct proc *p;
987 void *v;
988 register_t *retval;
989 {
990 struct compat_sparc32_getpeername_args /* {
991 syscallarg(int) fdes;
992 syscallarg(sparc32_sockaddrp_t) asa;
993 syscallarg(sparc32_intp) alen;
994 } */ *uap = v;
995 struct sys_getpeername_args ua;
996
997 SPARC32TO64_UAP(fdes);
998 SPARC32TOP_UAP(asa, struct sockaddr);
999 SPARC32TOP_UAP(alen, int);
1000 return (sys_getpeername(p, &ua, retval));
1001 }
1002
1003 int
1004 compat_sparc32_getsockname(p, v, retval)
1005 struct proc *p;
1006 void *v;
1007 register_t *retval;
1008 {
1009 struct compat_sparc32_getsockname_args /* {
1010 syscallarg(int) fdes;
1011 syscallarg(sparc32_sockaddrp_t) asa;
1012 syscallarg(sparc32_intp) alen;
1013 } */ *uap = v;
1014 struct sys_getsockname_args ua;
1015
1016 SPARC32TO64_UAP(fdes);
1017 SPARC32TOP_UAP(asa, struct sockaddr);
1018 SPARC32TOP_UAP(alen, int);
1019 return (sys_getsockname(p, &ua, retval));
1020 }
1021
1022 int
1023 compat_sparc32_access(p, v, retval)
1024 struct proc *p;
1025 void *v;
1026 register_t *retval;
1027 {
1028 struct compat_sparc32_access_args /* {
1029 syscallarg(const sparc32_charp) path;
1030 syscallarg(int) flags;
1031 } */ *uap = v;
1032 struct sys_access_args ua;
1033 caddr_t sg;
1034
1035 SPARC32TOP_UAP(path, const char);
1036 SPARC32TO64_UAP(flags);
1037 sg = stackgap_init(p->p_emul);
1038 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
1039
1040 return (sys_access(p, &ua, retval));
1041 }
1042
1043 int
1044 compat_sparc32_chflags(p, v, retval)
1045 struct proc *p;
1046 void *v;
1047 register_t *retval;
1048 {
1049 struct compat_sparc32_chflags_args /* {
1050 syscallarg(const sparc32_charp) path;
1051 syscallarg(sparc32_u_long) flags;
1052 } */ *uap = v;
1053 struct sys_chflags_args ua;
1054
1055 SPARC32TOP_UAP(path, const char);
1056 SPARC32TO64_UAP(flags);
1057
1058 return (sys_chflags(p, &ua, retval));
1059 }
1060
1061 int
1062 compat_sparc32_fchflags(p, v, retval)
1063 struct proc *p;
1064 void *v;
1065 register_t *retval;
1066 {
1067 struct compat_sparc32_fchflags_args /* {
1068 syscallarg(int) fd;
1069 syscallarg(sparc32_u_long) flags;
1070 } */ *uap = v;
1071 struct sys_fchflags_args ua;
1072
1073 SPARC32TO64_UAP(fd);
1074 SPARC32TO64_UAP(flags);
1075
1076 return (sys_fchflags(p, &ua, retval));
1077 }
1078
1079 int
1080 compat_sparc32_profil(p, v, retval)
1081 struct proc *p;
1082 void *v;
1083 register_t *retval;
1084 {
1085 struct compat_sparc32_profil_args /* {
1086 syscallarg(sparc32_caddr_t) samples;
1087 syscallarg(sparc32_size_t) size;
1088 syscallarg(sparc32_u_long) offset;
1089 syscallarg(u_int) scale;
1090 } */ *uap = v;
1091 struct sys_profil_args ua;
1092
1093 SPARC32TOX64_UAP(samples, caddr_t);
1094 SPARC32TOX_UAP(size, size_t);
1095 SPARC32TOX_UAP(offset, u_long);
1096 SPARC32TO64_UAP(scale);
1097 return (sys_profil(p, &ua, retval));
1098 }
1099
1100 int
1101 compat_sparc32_ktrace(p, v, retval)
1102 struct proc *p;
1103 void *v;
1104 register_t *retval;
1105 {
1106 struct compat_sparc32_ktrace_args /* {
1107 syscallarg(const sparc32_charp) fname;
1108 syscallarg(int) ops;
1109 syscallarg(int) facs;
1110 syscallarg(int) pid;
1111 } */ *uap = v;
1112 struct sys_ktrace_args ua;
1113
1114 SPARC32TOP_UAP(fname, const char);
1115 SPARC32TO64_UAP(ops);
1116 SPARC32TO64_UAP(facs);
1117 SPARC32TO64_UAP(pid);
1118 return (sys_ktrace(p, &ua, retval));
1119 }
1120
1121 int
1122 compat_sparc32_sigaction(p, v, retval)
1123 struct proc *p;
1124 void *v;
1125 register_t *retval;
1126 {
1127 struct compat_sparc32_sigaction_args /* {
1128 syscallarg(int) signum;
1129 syscallarg(const sparc32_sigactionp_t) nsa;
1130 syscallarg(sparc32_sigactionp_t) osa;
1131 } */ *uap = v;
1132 struct sys_sigaction_args ua;
1133 struct sigaction nsa, osa;
1134 struct sparc32_sigaction *sa32p, sa32;
1135 int error;
1136
1137 SPARC32TO64_UAP(signum);
1138 if (SCARG(uap, osa))
1139 SCARG(&ua, osa) = &osa;
1140 else
1141 SCARG(&ua, osa) = NULL;
1142 if (SCARG(uap, nsa)) {
1143 SCARG(&ua, nsa) = &nsa;
1144 sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, nsa);
1145 if (copyin(sa32p, &sa32, sizeof(sa32)))
1146 return EFAULT;
1147 nsa.sa_handler = (void *)(u_long)sa32.sa_handler;
1148 nsa.sa_mask = sa32.sa_mask;
1149 nsa.sa_flags = sa32.sa_flags;
1150 } else
1151 SCARG(&ua, nsa) = NULL;
1152 SCARG(&ua, nsa) = &osa;
1153 error = sys_sigaction(p, &ua, retval);
1154 if (error)
1155 return (error);
1156
1157 if (SCARG(uap, osa)) {
1158 sa32.sa_handler = (sparc32_sigactionp_t)(u_long)osa.sa_handler;
1159 sa32.sa_mask = osa.sa_mask;
1160 sa32.sa_flags = osa.sa_flags;
1161 sa32p = (struct sparc32_sigaction *)(u_long)SCARG(uap, osa);
1162 if (copyout(&sa32, sa32p, sizeof(sa32)))
1163 return EFAULT;
1164 }
1165
1166 return (0);
1167 }
1168
1169 int
1170 compat_sparc32___getlogin(p, v, retval)
1171 struct proc *p;
1172 void *v;
1173 register_t *retval;
1174 {
1175 struct compat_sparc32___getlogin_args /* {
1176 syscallarg(sparc32_charp) namebuf;
1177 syscallarg(u_int) namelen;
1178 } */ *uap = v;
1179 struct sys___getlogin_args ua;
1180
1181 SPARC32TOP_UAP(namebuf, char);
1182 SPARC32TO64_UAP(namelen);
1183 return (sys___getlogin(p, &ua, retval));
1184 }
1185
1186 int
1187 compat_sparc32_setlogin(p, v, retval)
1188 struct proc *p;
1189 void *v;
1190 register_t *retval;
1191 {
1192 struct compat_sparc32_setlogin_args /* {
1193 syscallarg(const sparc32_charp) namebuf;
1194 } */ *uap = v;
1195 struct sys_setlogin_args ua;
1196
1197 SPARC32TOP_UAP(namebuf, char);
1198 return (sys_setlogin(p, &ua, retval));
1199 }
1200
1201 int
1202 compat_sparc32_acct(p, v, retval)
1203 struct proc *p;
1204 void *v;
1205 register_t *retval;
1206 {
1207 struct compat_sparc32_acct_args /* {
1208 syscallarg(const sparc32_charp) path;
1209 } */ *uap = v;
1210 struct sys_acct_args ua;
1211
1212 SPARC32TOP_UAP(path, const char);
1213 return (sys_acct(p, &ua, retval));
1214 }
1215
1216 int
1217 compat_sparc32_revoke(p, v, retval)
1218 struct proc *p;
1219 void *v;
1220 register_t *retval;
1221 {
1222 struct compat_sparc32_revoke_args /* {
1223 syscallarg(const sparc32_charp) path;
1224 } */ *uap = v;
1225 struct sys_revoke_args ua;
1226 caddr_t sg;
1227
1228 SPARC32TOP_UAP(path, const char);
1229 sg = stackgap_init(p->p_emul);
1230 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
1231
1232 return (sys_revoke(p, &ua, retval));
1233 }
1234
1235 int
1236 compat_sparc32_symlink(p, v, retval)
1237 struct proc *p;
1238 void *v;
1239 register_t *retval;
1240 {
1241 struct compat_sparc32_symlink_args /* {
1242 syscallarg(const sparc32_charp) path;
1243 syscallarg(const sparc32_charp) link;
1244 } */ *uap = v;
1245 struct sys_symlink_args ua;
1246
1247 SPARC32TOP_UAP(path, const char);
1248 SPARC32TOP_UAP(link, const char);
1249
1250 return (sys_symlink(p, &ua, retval));
1251 }
1252
1253 int
1254 compat_sparc32_readlink(p, v, retval)
1255 struct proc *p;
1256 void *v;
1257 register_t *retval;
1258 {
1259 struct compat_sparc32_readlink_args /* {
1260 syscallarg(const sparc32_charp) path;
1261 syscallarg(sparc32_charp) buf;
1262 syscallarg(sparc32_size_t) count;
1263 } */ *uap = v;
1264 struct sys_readlink_args ua;
1265 caddr_t sg;
1266
1267 SPARC32TOP_UAP(path, const char);
1268 SPARC32TOP_UAP(buf, char);
1269 SPARC32TOX_UAP(count, size_t);
1270 sg = stackgap_init(p->p_emul);
1271 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
1272
1273 return (sys_readlink(p, &ua, retval));
1274 }
1275
1276 int
1277 compat_sparc32_execve(p, v, retval)
1278 struct proc *p;
1279 void *v;
1280 register_t *retval;
1281 {
1282 struct compat_sparc32_execve_args /* {
1283 syscallarg(const sparc32_charp) path;
1284 syscallarg(sparc32_charpp) argp;
1285 syscallarg(sparc32_charpp) envp;
1286 } */ *uap = v;
1287 struct sys_execve_args ua;
1288 caddr_t sg;
1289
1290 SPARC32TOP_UAP(path, const char);
1291 SPARC32TOP_UAP(argp, char *);
1292 SPARC32TOP_UAP(envp, char *);
1293 sg = stackgap_init(p->p_emul);
1294 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
1295
1296 return (sys_execve(p, &ua, retval));
1297 }
1298
1299 int
1300 compat_sparc32_chroot(p, v, retval)
1301 struct proc *p;
1302 void *v;
1303 register_t *retval;
1304 {
1305 struct compat_sparc32_chroot_args /* {
1306 syscallarg(const sparc32_charp) path;
1307 } */ *uap = v;
1308 struct sys_chroot_args ua;
1309
1310 SPARC32TOP_UAP(path, const char);
1311 return (sys_chroot(p, &ua, retval));
1312 }
1313
1314 int
1315 compat_sparc32_munmap(p, v, retval)
1316 struct proc *p;
1317 void *v;
1318 register_t *retval;
1319 {
1320 struct compat_sparc32_munmap_args /* {
1321 syscallarg(sparc32_voidp) addr;
1322 syscallarg(sparc32_size_t) len;
1323 } */ *uap = v;
1324 struct sys_munmap_args ua;
1325
1326 SPARC32TOP_UAP(addr, void);
1327 SPARC32TOX_UAP(len, size_t);
1328 return (sys_munmap(p, &ua, retval));
1329 }
1330
1331 int
1332 compat_sparc32_mprotect(p, v, retval)
1333 struct proc *p;
1334 void *v;
1335 register_t *retval;
1336 {
1337 struct compat_sparc32_mprotect_args /* {
1338 syscallarg(sparc32_voidp) addr;
1339 syscallarg(sparc32_size_t) len;
1340 syscallarg(int) prot;
1341 } */ *uap = v;
1342 struct sys_mprotect_args ua;
1343
1344 SPARC32TOP_UAP(addr, void);
1345 SPARC32TOX_UAP(len, size_t);
1346 SPARC32TO64_UAP(prot);
1347 return (sys_mprotect(p, &ua, retval));
1348 }
1349
1350 int
1351 compat_sparc32_madvise(p, v, retval)
1352 struct proc *p;
1353 void *v;
1354 register_t *retval;
1355 {
1356 struct compat_sparc32_madvise_args /* {
1357 syscallarg(sparc32_voidp) addr;
1358 syscallarg(sparc32_size_t) len;
1359 syscallarg(int) behav;
1360 } */ *uap = v;
1361 struct sys_madvise_args ua;
1362
1363 SPARC32TOP_UAP(addr, void);
1364 SPARC32TOX_UAP(len, size_t);
1365 SPARC32TO64_UAP(behav);
1366 return (sys_madvise(p, &ua, retval));
1367 }
1368
1369 int
1370 compat_sparc32_mincore(p, v, retval)
1371 struct proc *p;
1372 void *v;
1373 register_t *retval;
1374 {
1375 struct compat_sparc32_mincore_args /* {
1376 syscallarg(sparc32_caddr_t) addr;
1377 syscallarg(sparc32_size_t) len;
1378 syscallarg(sparc32_charp) vec;
1379 } */ *uap = v;
1380 struct sys_mincore_args ua;
1381
1382 SPARC32TOX64_UAP(addr, caddr_t);
1383 SPARC32TOX_UAP(len, size_t);
1384 SPARC32TOP_UAP(vec, char);
1385 return (sys_mincore(p, &ua, retval));
1386 }
1387
1388 int
1389 compat_sparc32_getgroups(p, v, retval)
1390 struct proc *p;
1391 void *v;
1392 register_t *retval;
1393 {
1394 struct compat_sparc32_getgroups_args /* {
1395 syscallarg(int) gidsetsize;
1396 syscallarg(sparc32_gid_tp) gidset;
1397 } */ *uap = v;
1398 struct sys_getgroups_args ua;
1399
1400 SPARC32TO64_UAP(gidsetsize);
1401 SPARC32TOP_UAP(gidset, gid_t);
1402 return (sys_getgroups(p, &ua, retval));
1403 }
1404
1405 int
1406 compat_sparc32_setgroups(p, v, retval)
1407 struct proc *p;
1408 void *v;
1409 register_t *retval;
1410 {
1411 struct compat_sparc32_setgroups_args /* {
1412 syscallarg(int) gidsetsize;
1413 syscallarg(const sparc32_gid_tp) gidset;
1414 } */ *uap = v;
1415 struct sys_setgroups_args ua;
1416
1417 SPARC32TO64_UAP(gidsetsize);
1418 SPARC32TOP_UAP(gidset, gid_t);
1419 return (sys_setgroups(p, &ua, retval));
1420 }
1421
1422 int
1423 compat_sparc32_setitimer(p, v, retval)
1424 struct proc *p;
1425 void *v;
1426 register_t *retval;
1427 {
1428 struct compat_sparc32_setitimer_args /* {
1429 syscallarg(int) which;
1430 syscallarg(const sparc32_itimervalp_t) itv;
1431 syscallarg(sparc32_itimervalp_t) oitv;
1432 } */ *uap = v;
1433 struct sys_setitimer_args ua;
1434 struct itimerval iit, oit;
1435 struct sparc32_itimerval *s32itp, s32it;
1436 int error;
1437
1438 SPARC32TO64_UAP(which);
1439 s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, itv);
1440 if (s32itp) {
1441 if (copyin(s32itp, &s32it, sizeof(s32it)))
1442 return EFAULT;
1443 SCARG(&ua, itv) = &iit;
1444 sparc32_to_itimerval(&s32it, &iit);
1445 } else
1446 SCARG(&ua, itv) = NULL;
1447 s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, oitv);
1448 if (s32itp)
1449 SCARG(&ua, oitv) = &oit;
1450 else
1451 SCARG(&ua, oitv) = NULL;
1452
1453 error = sys_setitimer(p, &ua, retval);
1454 if (error)
1455 return (error);
1456
1457 if (s32itp) {
1458 sparc32_from_itimerval(&oit, &s32it);
1459 if (copyout(&s32it, s32itp, sizeof(s32it)))
1460 return EFAULT;
1461 }
1462 return (0);
1463 }
1464
1465 int
1466 compat_sparc32_getitimer(p, v, retval)
1467 struct proc *p;
1468 void *v;
1469 register_t *retval;
1470 {
1471 struct compat_sparc32_getitimer_args /* {
1472 syscallarg(int) which;
1473 syscallarg(sparc32_itimervalp_t) itv;
1474 } */ *uap = v;
1475 struct sys_getitimer_args ua;
1476 struct itimerval it;
1477 struct sparc32_itimerval *s32itp, s32it;
1478 int error;
1479
1480 SPARC32TO64_UAP(which);
1481 s32itp = (struct sparc32_itimerval *)(u_long)SCARG(uap, itv);
1482 if (s32itp == NULL)
1483 SCARG(&ua, itv) = ⁢
1484 else
1485 SCARG(&ua, itv) = NULL;
1486
1487 error = sys_getitimer(p, &ua, retval);
1488 if (error)
1489 return (error);
1490
1491 if (s32itp) {
1492 sparc32_from_itimerval(&it, &s32it);
1493 if (copyout(&s32it, s32itp, sizeof(s32it)))
1494 return EFAULT;
1495 }
1496 return (0);
1497 }
1498
1499 int
1500 compat_sparc32_fcntl(p, v, retval)
1501 struct proc *p;
1502 void *v;
1503 register_t *retval;
1504 {
1505 struct compat_sparc32_fcntl_args /* {
1506 syscallarg(int) fd;
1507 syscallarg(int) cmd;
1508 syscallarg(sparc32_voidp) arg;
1509 } */ *uap = v;
1510 struct sys_fcntl_args ua;
1511
1512 SPARC32TO64_UAP(fd);
1513 SPARC32TO64_UAP(cmd);
1514 SPARC32TOP_UAP(arg, void);
1515 return (sys_fcntl(p, &ua, retval));
1516 }
1517
1518 int
1519 compat_sparc32_select(p, v, retval)
1520 struct proc *p;
1521 void *v;
1522 register_t *retval;
1523 {
1524 struct compat_sparc32_select_args /* {
1525 syscallarg(int) nd;
1526 syscallarg(sparc32_fd_setp_t) in;
1527 syscallarg(sparc32_fd_setp_t) ou;
1528 syscallarg(sparc32_fd_setp_t) ex;
1529 syscallarg(sparc32_timevalp_t) tv;
1530 } */ *uap = v;
1531 struct sys_select_args ua;
1532 struct timeval tv;
1533 struct sparc32_timeval *tv32p, tv32;
1534 int error;
1535
1536 SPARC32TO64_UAP(nd);
1537 SPARC32TOP_UAP(in, fd_set);
1538 SPARC32TOP_UAP(ou, fd_set);
1539 SPARC32TOP_UAP(ex, fd_set);
1540 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tv);
1541 if (tv32p) {
1542 if (copyin(tv32p &tv32, sizeof(tv32)))
1543 return EFAULT;
1544 sparc32_to_timeval(&tv32, &tv);
1545 }
1546 SCARG(&ua, tv) = &tv;
1547
1548 error = sys_select(p, &ua, retval);
1549 if (tv32p) {
1550 sparc32_from_timeval(&tv, &tv32);
1551 if (copyout(&tv32 tv32p, sizeof(tv32)))
1552 return EFAULT;
1553 }
1554
1555 return (error);
1556 }
1557
1558 int
1559 compat_sparc32_connect(p, v, retval)
1560 struct proc *p;
1561 void *v;
1562 register_t *retval;
1563 {
1564 struct compat_sparc32_connect_args /* {
1565 syscallarg(int) s;
1566 syscallarg(const sparc32_sockaddrp_t) name;
1567 syscallarg(int) namelen;
1568 } */ *uap = v;
1569 struct sys_connect_args ua;
1570
1571 SPARC32TO64_UAP(s);
1572 SPARC32TOP_UAP(name, struct sockaddr);
1573 SPARC32TO64_UAP(namelen);
1574 return (sys_connect(p, &ua, retval));
1575 }
1576
1577 #undef DEBUG
1578 int
1579 compat_sparc32_sigreturn(p, v, retval)
1580 struct proc *p;
1581 void *v;
1582 register_t *retval;
1583 {
1584 struct compat_sparc32_sigreturn_args /* {
1585 syscallarg(struct sparc32_sigcontext *) sigcntxp;
1586 } */ *uap = v;
1587 struct sparc32_sigcontext *scp;
1588 struct sparc32_sigcontext sc;
1589 register struct trapframe *tf;
1590 struct rwindow32 *rwstack, *kstack;
1591 int i;
1592
1593 /* First ensure consistent stack state (see sendsig). */
1594 write_user_windows();
1595 if (rwindow_save(p)) {
1596 #ifdef DEBUG
1597 printf("sigreturn: rwindow_save(%p) failed, sending SIGILL\n", p);
1598 Debugger();
1599 #endif
1600 sigexit(p, SIGILL);
1601 }
1602 #ifdef DEBUG
1603 if (sigdebug & SDB_FOLLOW) {
1604 printf("sigreturn: %s[%d], sigcntxp %p\n",
1605 p->p_comm, p->p_pid, SCARG(uap, sigcntxp));
1606 if (sigdebug & SDB_DDB) Debugger();
1607 }
1608 #endif
1609 scp = SCARG(uap, sigcntxp);
1610 if ((int)scp & 3 || (copyin((caddr_t)scp, &sc, sizeof sc) != 0))
1611 #ifdef DEBUG
1612 {
1613 printf("sigreturn: copyin failed\n");
1614 Debugger();
1615 return (EINVAL);
1616 }
1617 #else
1618 return (EINVAL);
1619 #endif
1620 tf = p->p_md.md_tf;
1621 /*
1622 * Only the icc bits in the psr are used, so it need not be
1623 * verified. pc and npc must be multiples of 4. This is all
1624 * that is required; if it holds, just do it.
1625 */
1626 if (((sc.sc_pc | sc.sc_npc) & 3) != 0)
1627 #ifdef DEBUG
1628 {
1629 printf("sigreturn: pc %p or npc %p invalid\n", sc.sc_pc, sc.sc_npc);
1630 Debugger();
1631 return (EINVAL);
1632 }
1633 #else
1634 return (EINVAL);
1635 #endif
1636 /* take only psr ICC field */
1637 tf->tf_tstate = (int64_t)(tf->tf_tstate & ~TSTATE_CCR) | PSRCC_TO_TSTATE(sc.sc_psr);
1638 tf->tf_pc = (int64_t)sc.sc_pc;
1639 tf->tf_npc = (int64_t)sc.sc_npc;
1640 tf->tf_global[1] = (int64_t)sc.sc_g1;
1641 tf->tf_out[0] = (int64_t)sc.sc_o0;
1642 tf->tf_out[6] = (int64_t)sc.sc_sp;
1643 rwstack = (struct rwindow32 *)tf->tf_out[6];
1644 kstack = (struct rwindow32 *)(((caddr_t)tf)-CCFSZ);
1645 for (i=0; i<8; i++) {
1646 int tmp;
1647 if (copyin((caddr_t)&rwstack->rw_local[i], &tmp, sizeof tmp)) {
1648 printf("sigreturn: cannot load \%l%d from %p\n", i, &rwstack->rw_local[i]);
1649 Debugger();
1650 }
1651 tf->tf_local[i] = (int64_t)tmp;
1652 if (copyin((caddr_t)&rwstack->rw_in[i], &tmp, sizeof tmp)) {
1653 printf("sigreturn: cannot load \%i%d from %p\n", i, &rwstack->rw_in[i]);
1654 Debugger();
1655 }
1656 tf->tf_in[i] = (int)tmp;
1657 }
1658 #ifdef DEBUG
1659 /* Need to sync tf locals and ins with stack to prevent panic */
1660 {
1661 int i;
1662
1663 kstack = (struct rwindow32 *)tf->tf_out[6];
1664 for (i=0; i<8; i++) {
1665 tf->tf_local[i] = fuword(&kstack->rw_local[i]);
1666 tf->tf_in[i] = fuword(&kstack->rw_in[i]);
1667 }
1668 }
1669 #endif
1670 #ifdef DEBUG
1671 if (sigdebug & SDB_FOLLOW) {
1672 printf("sys_sigreturn: return trapframe pc=%p sp=%p tstate=%x\n",
1673 (int)tf->tf_pc, (int)tf->tf_out[6], (int)tf->tf_tstate);
1674 if (sigdebug & SDB_DDB) Debugger();
1675 }
1676 #endif
1677 if (sc.sc_onstack & 1)
1678 p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
1679 else
1680 p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
1681 p->p_sigmask = sc.sc_mask & ~sigcantmask;
1682 return (EJUSTRETURN);
1683 }
1684
1685
1686 int
1687 compat_sparc32_bind(p, v, retval)
1688 struct proc *p;
1689 void *v;
1690 register_t *retval;
1691 {
1692 struct compat_sparc32_bind_args /* {
1693 syscallarg(int) s;
1694 syscallarg(const sparc32_sockaddrp_t) name;
1695 syscallarg(int) namelen;
1696 } */ *uap = v;
1697 struct sys_connect_args ua;
1698
1699 SPARC32TO64_UAP(s);
1700 SPARC32TOP_UAP(name, struct sockaddr);
1701 SPARC32TO64_UAP(namelen);
1702 return (sys_connect(p, &ua, retval));
1703 }
1704
1705 int
1706 compat_sparc32_setsockopt(p, v, retval)
1707 struct proc *p;
1708 void *v;
1709 register_t *retval;
1710 {
1711 struct compat_sparc32_setsockopt_args /* {
1712 syscallarg(int) s;
1713 syscallarg(int) level;
1714 syscallarg(int) name;
1715 syscallarg(const sparc32_voidp) val;
1716 syscallarg(int) valsize;
1717 } */ *uap = v;
1718 struct sys_setsockopt_args ua;
1719
1720 SPARC32TO64_UAP(s);
1721 SPARC32TO64_UAP(level);
1722 SPARC32TO64_UAP(name);
1723 SPARC32TOP_UAP(val, void);
1724 SPARC32TO64_UAP(valsize);
1725 return (sys_setsockopt(p, &ua, retval));
1726 }
1727
1728 int
1729 compat_sparc32_gettimeofday(p, v, retval)
1730 struct proc *p;
1731 void *v;
1732 register_t *retval;
1733 {
1734 struct compat_sparc32_gettimeofday_args /* {
1735 syscallarg(sparc32_timevalp_t) tp;
1736 syscallarg(sparc32_timezonep_t) tzp;
1737 } */ *uap = v;
1738 struct sys_gettimeofday_args ua;
1739 struct timeval tv;
1740 struct sparc32_timeval *tv32p, tv32;
1741 int error;
1742
1743 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tp);
1744 if (tv32p) {
1745 SCARG(&ua, tp) = &tv;
1746 if (copyin(tv32p, &tv32, sizeof(tv32)))
1747 return EINVAL;
1748 sparc32_to_timeval(tv32p, &tv);
1749 } else
1750 SCARG(&ua, tp) = NULL;
1751 SPARC32TOP_UAP(tzp, struct timezone)
1752
1753 error = sys_gettimeofday(p, &ua, retval);
1754 if (error)
1755 return (error);
1756
1757 if (tv32p)
1758 sparc32_from_timeval(&tv, tv32p);
1759
1760 return (0);
1761 }
1762
1763 int
1764 compat_sparc32_settimeofday(p, v, retval)
1765 struct proc *p;
1766 void *v;
1767 register_t *retval;
1768 {
1769 struct compat_sparc32_settimeofday_args /* {
1770 syscallarg(const sparc32_timevalp_t) tv;
1771 syscallarg(const sparc32_timezonep_t) tzp;
1772 } */ *uap = v;
1773 struct sys_settimeofday_args ua;
1774 struct timeval tv;
1775 struct sparc32_timeval *tv32p;
1776 int error;
1777
1778 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tv);
1779 if (tv32p) {
1780 SCARG(&ua, tv) = &tv;
1781 sparc32_to_timeval(tv32p, &tv);
1782 } else
1783 SCARG(&ua, tv) = NULL;
1784 SPARC32TOP_UAP(tzp, struct timezone)
1785
1786 error = sys_settimeofday(p, &ua, retval);
1787 if (error)
1788 return (error);
1789
1790 if (tv32p)
1791 sparc32_from_timeval(&tv, tv32p);
1792
1793 return (0);
1794 }
1795
1796 int
1797 compat_sparc32_getrusage(p, v, retval)
1798 struct proc *p;
1799 void *v;
1800 register_t *retval;
1801 {
1802 struct compat_sparc32_getrusage_args /* {
1803 syscallarg(int) who;
1804 syscallarg(sparc32_rusagep_t) rusage;
1805 } */ *uap = v;
1806 struct sys_getrusage_args ua;
1807 struct rusage ru;
1808 struct sparc32_rusage *ru32p;
1809 int error;
1810
1811 SPARC32TO64_UAP(who);
1812 ru32p = (struct sparc32_rusage *)(u_long)SCARG(uap, rusage);
1813 if (ru32p) {
1814 SCARG(&ua, rusage) = &ru;
1815 sparc32_to_rusage(ru32p, &ru);
1816 } else
1817 SCARG(&ua, rusage) = NULL;
1818
1819 error = sys_getrusage(p, &ua, retval);
1820 if (ru32p)
1821 sparc32_from_rusage(&ru, ru32p);
1822
1823 return (error);
1824 }
1825
1826 int
1827 compat_sparc32_getsockopt(p, v, retval)
1828 struct proc *p;
1829 void *v;
1830 register_t *retval;
1831 {
1832 struct compat_sparc32_getsockopt_args /* {
1833 syscallarg(int) s;
1834 syscallarg(int) level;
1835 syscallarg(int) name;
1836 syscallarg(sparc32_voidp) val;
1837 syscallarg(sparc32_intp) avalsize;
1838 } */ *uap = v;
1839 struct sys_getsockopt_args ua;
1840
1841 SPARC32TO64_UAP(s);
1842 SPARC32TO64_UAP(level);
1843 SPARC32TO64_UAP(name);
1844 SPARC32TOP_UAP(val, void)
1845 SPARC32TOP_UAP(avalsize, int);
1846 return (sys_getsockopt(p, &ua, retval));
1847 }
1848
1849 int
1850 compat_sparc32_readv(p, v, retval)
1851 struct proc *p;
1852 void *v;
1853 register_t *retval;
1854 {
1855 struct compat_sparc32_readv_args /* {
1856 syscallarg(int) fd;
1857 syscallarg(const sparc32_iovecp_t) iovp;
1858 syscallarg(int) iovcnt;
1859 } */ *uap = v;
1860 struct sys_readv_args ua;
1861 struct iovec *iov;
1862 ssize_t rt;
1863 int error;
1864
1865 SPARC32TO64_UAP(fd)
1866 SPARC32TO64_UAP(iovcnt);
1867 MALLOC(iov, struct iovec *,
1868 sizeof(struct iovec) * SCARG(uap, iovcnt), M_TEMP, M_WAITOK);
1869 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
1870 SCARG(uap, iovcnt));
1871 SCARG(&ua, iovp) = iov;
1872
1873 error = sys_readv(p, &ua, (register_t *)&rt);
1874 FREE(iov, M_TEMP);
1875 *(sparc32_ssize_t *)retval = rt;
1876 return (error);
1877 }
1878
1879 int
1880 compat_sparc32_writev(p, v, retval)
1881 struct proc *p;
1882 void *v;
1883 register_t *retval;
1884 {
1885 struct compat_sparc32_writev_args /* {
1886 syscallarg(int) fd;
1887 syscallarg(const sparc32_iovecp_t) iovp;
1888 syscallarg(int) iovcnt;
1889 } */ *uap = v;
1890 struct sys_writev_args ua;
1891 struct iovec *iov;
1892 ssize_t rt;
1893 int error;
1894
1895 SPARC32TO64_UAP(fd)
1896 SPARC32TO64_UAP(iovcnt);
1897 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
1898 M_TEMP, M_WAITOK);
1899 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
1900 SCARG(uap, iovcnt));
1901 SCARG(&ua, iovp) = iov;
1902
1903 error = sys_writev(p, &ua, (register_t *)&rt);
1904 FREE(iov, M_TEMP);
1905 *(sparc32_ssize_t *)retval = rt;
1906 return (error);
1907 }
1908
1909 int
1910 compat_sparc32_rename(p, v, retval)
1911 struct proc *p;
1912 void *v;
1913 register_t *retval;
1914 {
1915 struct compat_sparc32_rename_args /* {
1916 syscallarg(const sparc32_charp) from;
1917 syscallarg(const sparc32_charp) to;
1918 } */ *uap = v;
1919 struct sys_rename_args ua;
1920
1921 SPARC32TOP_UAP(from, const char)
1922 SPARC32TOP_UAP(to, const char)
1923 return (sys_rename(p, &ua, retval));
1924 }
1925
1926 int
1927 compat_sparc32_mkfifo(p, v, retval)
1928 struct proc *p;
1929 void *v;
1930 register_t *retval;
1931 {
1932 struct compat_sparc32_mkfifo_args /* {
1933 syscallarg(const sparc32_charp) path;
1934 syscallarg(mode_t) mode;
1935 } */ *uap = v;
1936 struct sys_mkfifo_args ua;
1937
1938 SPARC32TOP_UAP(path, const char)
1939 SPARC32TO64_UAP(mode);
1940 return (sys_mkfifo(p, &ua, retval));
1941 }
1942
1943 int
1944 compat_sparc32_mkdir(p, v, retval)
1945 struct proc *p;
1946 void *v;
1947 register_t *retval;
1948 {
1949 struct compat_sparc32_mkdir_args /* {
1950 syscallarg(const sparc32_charp) path;
1951 syscallarg(mode_t) mode;
1952 } */ *uap = v;
1953 struct sys_mkdir_args ua;
1954
1955 SPARC32TOP_UAP(path, const char)
1956 SPARC32TO64_UAP(mode);
1957 return (sys_mkdir(p, &ua, retval));
1958 }
1959
1960 int
1961 compat_sparc32_rmdir(p, v, retval)
1962 struct proc *p;
1963 void *v;
1964 register_t *retval;
1965 {
1966 struct compat_sparc32_rmdir_args /* {
1967 syscallarg(const sparc32_charp) path;
1968 } */ *uap = v;
1969 struct sys_rmdir_args ua;
1970
1971 SPARC32TOP_UAP(path, const char);
1972 return (sys_rmdir(p, &ua, retval));
1973 }
1974
1975 int
1976 compat_sparc32_utimes(p, v, retval)
1977 struct proc *p;
1978 void *v;
1979 register_t *retval;
1980 {
1981 struct compat_sparc32_utimes_args /* {
1982 syscallarg(const sparc32_charp) path;
1983 syscallarg(const sparc32_timevalp_t) tptr;
1984 } */ *uap = v;
1985 struct sys_utimes_args ua;
1986 struct timeval tv;
1987 struct sparc32_timeval *tv32p;
1988
1989 SPARC32TOP_UAP(path, const char);
1990 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
1991 if (tv32p) {
1992 SCARG(&ua, tptr) = &tv;
1993 sparc32_to_timeval(tv32p, &tv);
1994 } else
1995 SCARG(&ua, tptr) = NULL;
1996
1997 return (sys_utimes(p, &ua, retval));
1998 }
1999
2000 int
2001 compat_sparc32_adjtime(p, v, retval)
2002 struct proc *p;
2003 void *v;
2004 register_t *retval;
2005 {
2006 struct compat_sparc32_adjtime_args /* {
2007 syscallarg(const sparc32_timevalp_t) delta;
2008 syscallarg(sparc32_timevalp_t) olddelta;
2009 } */ *uap = v;
2010 struct sys_adjtime_args ua;
2011 struct timeval tv, otv;
2012 struct sparc32_timeval *tv32p, *otv32p;
2013 int error;
2014
2015 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, delta);
2016 otv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, olddelta);
2017
2018 if (tv32p) {
2019 SCARG(&ua, delta) = &tv;
2020 sparc32_to_timeval(tv32p, &tv);
2021 } else
2022 SCARG(&ua, delta) = NULL;
2023 if (otv32p)
2024 SCARG(&ua, olddelta) = &otv;
2025 else
2026 SCARG(&ua, olddelta) = NULL;
2027 error = sys_adjtime(p, &ua, retval);
2028 if (error)
2029 return (error);
2030
2031 if (otv32p)
2032 sparc32_from_timeval(&otv, otv32p);
2033 return (0);
2034 }
2035
2036 int
2037 compat_sparc32_quotactl(p, v, retval)
2038 struct proc *p;
2039 void *v;
2040 register_t *retval;
2041 {
2042 struct compat_sparc32_quotactl_args /* {
2043 syscallarg(const sparc32_charp) path;
2044 syscallarg(int) cmd;
2045 syscallarg(int) uid;
2046 syscallarg(sparc32_caddr_t) arg;
2047 } */ *uap = v;
2048 struct sys_quotactl_args ua;
2049
2050 SPARC32TOP_UAP(path, const char);
2051 SPARC32TO64_UAP(cmd);
2052 SPARC32TO64_UAP(uid);
2053 SPARC32TOX64_UAP(arg, caddr_t);
2054 return (sys_quotactl(p, &ua, retval));
2055 }
2056
2057 int
2058 compat_sparc32_nfssvc(p, v, retval)
2059 struct proc *p;
2060 void *v;
2061 register_t *retval;
2062 {
2063 struct compat_sparc32_nfssvc_args /* {
2064 syscallarg(int) flag;
2065 syscallarg(sparc32_voidp) argp;
2066 } */ *uap = v;
2067 struct sys_nfssvc_args ua;
2068
2069 SPARC32TO64_UAP(flag);
2070 SPARC32TOP_UAP(argp, void);
2071 return (sys_nfssvc(p, &ua, retval));
2072 }
2073
2074 int
2075 compat_sparc32_statfs(p, v, retval)
2076 struct proc *p;
2077 void *v;
2078 register_t *retval;
2079 {
2080 struct compat_sparc32_statfs_args /* {
2081 syscallarg(const sparc32_charp) path;
2082 syscallarg(sparc32_statfsp_t) buf;
2083 } */ *uap = v;
2084 struct sys_statfs_args ua;
2085 struct statfs sb;
2086 struct sparc32_statfs *sb32p;
2087 caddr_t sg;
2088 int error;
2089
2090 SPARC32TOP_UAP(path, const char);
2091 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
2092 if (sb32p)
2093 SCARG(&ua, buf) = &sb;
2094 else
2095 SCARG(&ua, buf) = NULL;
2096 sg = stackgap_init(p->p_emul);
2097 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
2098 error = sys_statfs(p, &ua, retval);
2099 if (error)
2100 return (error);
2101
2102 if (sb32p)
2103 sparc32_from_statfs(&sb, sb32p);
2104 return (0);
2105 }
2106
2107 int
2108 compat_sparc32_fstatfs(p, v, retval)
2109 struct proc *p;
2110 void *v;
2111 register_t *retval;
2112 {
2113 struct compat_sparc32_fstatfs_args /* {
2114 syscallarg(int) fd;
2115 syscallarg(sparc32_statfsp_t) buf;
2116 } */ *uap = v;
2117 struct sys_fstatfs_args ua;
2118 struct statfs sb;
2119 struct sparc32_statfs *sb32p;
2120 int error;
2121
2122 SPARC32TO64_UAP(fd);
2123 sb32p = (struct sparc32_statfs *)(u_long)SCARG(uap, buf);
2124 if (sb32p)
2125 SCARG(&ua, buf) = &sb;
2126 else
2127 SCARG(&ua, buf) = NULL;
2128 error = sys_fstatfs(p, &ua, retval);
2129 if (error)
2130 return (error);
2131
2132 if (sb32p)
2133 sparc32_from_statfs(&sb, sb32p);
2134 return (0);
2135 }
2136
2137 int
2138 compat_sparc32_getfh(p, v, retval)
2139 struct proc *p;
2140 void *v;
2141 register_t *retval;
2142 {
2143 struct compat_sparc32_getfh_args /* {
2144 syscallarg(const sparc32_charp) fname;
2145 syscallarg(sparc32_fhandlep_t) fhp;
2146 } */ *uap = v;
2147 struct sys_getfh_args ua;
2148
2149 SPARC32TOP_UAP(fname, const char);
2150 SPARC32TOP_UAP(fhp, struct fhandle);
2151 return (sys_getfh(p, &ua, retval));
2152 }
2153
2154 int
2155 compat_sparc32_sysarch(p, v, retval)
2156 struct proc *p;
2157 void *v;
2158 register_t *retval;
2159 {
2160 struct compat_sparc32_sysarch_args /* {
2161 syscallarg(int) op;
2162 syscallarg(sparc32_voidp) parms;
2163 } */ *uap = v;
2164 struct sys_sysarch_args ua;
2165
2166 SPARC32TO64_UAP(op);
2167 SPARC32TOP_UAP(parms, void);
2168 return (sys_getfh(p, &ua, retval));
2169 }
2170
2171 int
2172 compat_sparc32_pread(p, v, retval)
2173 struct proc *p;
2174 void *v;
2175 register_t *retval;
2176 {
2177 struct compat_sparc32_pread_args /* {
2178 syscallarg(int) fd;
2179 syscallarg(sparc32_voidp) buf;
2180 syscallarg(sparc32_size_t) nbyte;
2181 syscallarg(int) pad;
2182 syscallarg(off_t) offset;
2183 } */ *uap = v;
2184 struct sys_pread_args ua;
2185 ssize_t rt;
2186 int error;
2187
2188 SPARC32TO64_UAP(fd);
2189 SPARC32TOP_UAP(buf, void);
2190 SPARC32TOX_UAP(nbyte, size_t);
2191 SPARC32TO64_UAP(pad);
2192 SPARC32TO64_UAP(offset);
2193 error = sys_pread(p, &ua, (register_t *)&rt);
2194 *(sparc32_ssize_t *)retval = rt;
2195 return (error);
2196 }
2197
2198 int
2199 compat_sparc32_pwrite(p, v, retval)
2200 struct proc *p;
2201 void *v;
2202 register_t *retval;
2203 {
2204 struct compat_sparc32_pwrite_args /* {
2205 syscallarg(int) fd;
2206 syscallarg(const sparc32_voidp) buf;
2207 syscallarg(sparc32_size_t) nbyte;
2208 syscallarg(int) pad;
2209 syscallarg(off_t) offset;
2210 } */ *uap = v;
2211 struct sys_pwrite_args ua;
2212 ssize_t rt;
2213 int error;
2214
2215 SPARC32TO64_UAP(fd);
2216 SPARC32TOP_UAP(buf, void);
2217 SPARC32TOX_UAP(nbyte, size_t);
2218 SPARC32TO64_UAP(pad);
2219 SPARC32TO64_UAP(offset);
2220 error = sys_pwrite(p, &ua, (register_t *)&rt);
2221 *(sparc32_ssize_t *)retval = rt;
2222 return (error);
2223 }
2224
2225 int
2226 compat_sparc32_ntp_gettime(p, v, retval)
2227 struct proc *p;
2228 void *v;
2229 register_t *retval;
2230 {
2231 struct compat_sparc32_ntp_gettime_args /* {
2232 syscallarg(sparc32_ntptimevalp_t) ntvp;
2233 } */ *uap = v;
2234 struct sys_ntp_gettime_args ua;
2235 struct ntptimeval ntv;
2236 struct sparc32_ntptimeval *ntv32p;
2237 int error;
2238
2239 ntv32p = (struct sparc32_ntptimeval *)(u_long)SCARG(uap, ntvp);
2240 if (ntv32p)
2241 SCARG(&ua, ntvp) = &ntv;
2242 else
2243 SCARG(&ua, ntvp) = NULL;
2244 error = sys_ntp_gettime(p, &ua, retval);
2245 if (error)
2246 return (error);
2247
2248 if (ntv32p) {
2249 sparc32_from_timeval(&ntv, ntv32p);
2250 ntv32.maxerror = (sparc32_long)ntv.maxerror;
2251 ntv32.esterror = (sparc32_long)ntv.esterror;
2252 }
2253 return (0);
2254 }
2255
2256 int
2257 compat_sparc32_ntp_adjtime(p, v, retval)
2258 struct proc *p;
2259 void *v;
2260 register_t *retval;
2261 {
2262 struct compat_sparc32_ntp_adjtime_args /* {
2263 syscallarg(sparc32_timexp_t) tp;
2264 } */ *uap = v;
2265 struct sys_ntp_adjtime_args ua;
2266 struct timex tx;
2267 struct sparc32_timex *tx32p;
2268 int error;
2269
2270 tx32p = (struct sparc32_timex *)(u_long)SCARG(uap, tp);
2271 if (tx32p) {
2272 SCARG(&ua, tp) = &tx;
2273 sparc32_to_timex(tx32p, &tx);
2274 } else
2275 SCARG(&ua, tp) = NULL;
2276 error = sys_ntp_adjtime(p, &ua, retval);
2277 if (error)
2278 return (error);
2279
2280 if (tx32p)
2281 sparc32_from_timeval(&tx, tx32p);
2282 return (0);
2283 }
2284
2285 int
2286 compat_sparc32_lfs_bmapv(p, v, retval)
2287 struct proc *p;
2288 void *v;
2289 register_t *retval;
2290 {
2291 struct compat_sparc32_lfs_bmapv_args /* {
2292 syscallarg(sparc32_fsid_tp_t) fsidp;
2293 syscallarg(sparc32_block_infop_t) blkiov;
2294 syscallarg(int) blkcnt;
2295 } */ *uap = v;
2296 #if 0
2297 struct sys_lfs_bmapv_args ua;
2298
2299 SPARC32TOP_UAP(fdidp, struct fsid);
2300 SPARC32TO64_UAP(blkcnt);
2301 /* XXX finish me */
2302 #else
2303
2304 return (ENOSYS); /* XXX */
2305 #endif
2306 }
2307
2308 int
2309 compat_sparc32_lfs_markv(p, v, retval)
2310 struct proc *p;
2311 void *v;
2312 register_t *retval;
2313 {
2314 struct compat_sparc32_lfs_markv_args /* {
2315 syscallarg(sparc32_fsid_tp_t) fsidp;
2316 syscallarg(sparc32_block_infop_t) blkiov;
2317 syscallarg(int) blkcnt;
2318 } */ *uap = v;
2319
2320 return (ENOSYS); /* XXX */
2321 }
2322
2323 int
2324 compat_sparc32_lfs_segclean(p, v, retval)
2325 struct proc *p;
2326 void *v;
2327 register_t *retval;
2328 {
2329 struct compat_sparc32_lfs_segclean_args /* {
2330 syscallarg(sparc32_fsid_tp_t) fsidp;
2331 syscallarg(sparc32_u_long) segment;
2332 } */ *uap = v;
2333 return (ENOSYS); /* XXX */
2334 }
2335
2336 int
2337 compat_sparc32_lfs_segwait(p, v, retval)
2338 struct proc *p;
2339 void *v;
2340 register_t *retval;
2341 {
2342 struct compat_sparc32_lfs_segwait_args /* {
2343 syscallarg(sparc32_fsid_tp_t) fsidp;
2344 syscallarg(sparc32_timevalp_t) tv;
2345 } */ *uap = v;
2346 return (ENOSYS); /* XXX */
2347 }
2348
2349 int
2350 compat_sparc32_pathconf(p, v, retval)
2351 struct proc *p;
2352 void *v;
2353 register_t *retval;
2354 {
2355 struct compat_sparc32_pathconf_args /* {
2356 syscallarg(int) fd;
2357 syscallarg(int) name;
2358 } */ *uap = v;
2359 struct sys_pathconf_args ua;
2360 long rt;
2361 int error;
2362
2363 SPARC32TOP_UAP(path, const char);
2364 SPARC32TO64_UAP(name);
2365 error = sys_pathconf(p, &ua, (register_t *)&rt);
2366 *(sparc32_long *)retval = (sparc32_long)rt;
2367 return (error);
2368 }
2369
2370 int
2371 compat_sparc32_fpathconf(p, v, retval)
2372 struct proc *p;
2373 void *v;
2374 register_t *retval;
2375 {
2376 struct compat_sparc32_fpathconf_args /* {
2377 syscallarg(int) fd;
2378 syscallarg(int) name;
2379 } */ *uap = v;
2380 struct sys_fpathconf_args ua;
2381 long rt;
2382 int error;
2383
2384 SPARC32TO64_UAP(fd);
2385 SPARC32TO64_UAP(name);
2386 error = sys_fpathconf(p, &ua, (register_t *)&rt);
2387 *(sparc32_long *)retval = (sparc32_long)rt;
2388 return (error);
2389 }
2390
2391 int
2392 compat_sparc32_getrlimit(p, v, retval)
2393 struct proc *p;
2394 void *v;
2395 register_t *retval;
2396 {
2397 struct compat_sparc32_getrlimit_args /* {
2398 syscallarg(int) which;
2399 syscallarg(sparc32_rlimitp_t) rlp;
2400 } */ *uap = v;
2401 struct sys_getrlimit_args ua;
2402
2403 SPARC32TO64_UAP(which);
2404 SPARC32TOP_UAP(rlp, struct rlimit);
2405 return (sys_getrlimit(p, &ua, retval));
2406 }
2407
2408 int
2409 compat_sparc32_setrlimit(p, v, retval)
2410 struct proc *p;
2411 void *v;
2412 register_t *retval;
2413 {
2414 struct compat_sparc32_setrlimit_args /* {
2415 syscallarg(int) which;
2416 syscallarg(const sparc32_rlimitp_t) rlp;
2417 } */ *uap = v;
2418 struct sys_setrlimit_args ua;
2419
2420 SPARC32TO64_UAP(which);
2421 SPARC32TOP_UAP(rlp, struct rlimit);
2422 return (sys_setrlimit(p, &ua, retval));
2423 }
2424
2425 int
2426 compat_sparc32_mmap(p, v, retval)
2427 struct proc *p;
2428 void *v;
2429 register_t *retval;
2430 {
2431 struct compat_sparc32_mmap_args /* {
2432 syscallarg(sparc32_voidp) addr;
2433 syscallarg(sparc32_size_t) len;
2434 syscallarg(int) prot;
2435 syscallarg(int) flags;
2436 syscallarg(int) fd;
2437 syscallarg(sparc32_long) pad;
2438 syscallarg(off_t) pos;
2439 } */ *uap = v;
2440 struct sys_mmap_args ua;
2441 void *rt;
2442 int error;
2443
2444 SPARC32TOP_UAP(addr, void);
2445 SPARC32TOX_UAP(len, size_t);
2446 SPARC32TO64_UAP(prot);
2447 SPARC32TO64_UAP(flags);
2448 SPARC32TO64_UAP(fd);
2449 SPARC32TOX_UAP(pad, long);
2450 SPARC32TOX_UAP(pos, off_t);
2451 error = sys_mmap(p, &ua, (register_t *)&rt);
2452 if ((long)rt > (long)UINT_MAX)
2453 printf("compat_sparc32_mmap: retval out of range: 0x%qx",
2454 rt);
2455 *retval = (sparc32_voidp)(u_long)rt;
2456 return (error);
2457 }
2458
2459 int
2460 compat_sparc32_truncate(p, v, retval)
2461 struct proc *p;
2462 void *v;
2463 register_t *retval;
2464 {
2465 struct compat_sparc32_truncate_args /* {
2466 syscallarg(const sparc32_charp) path;
2467 syscallarg(int) pad;
2468 syscallarg(off_t) length;
2469 } */ *uap = v;
2470 struct sys_truncate_args ua;
2471
2472 SPARC32TOP_UAP(path, const char);
2473 SPARC32TO64_UAP(pad);
2474 SPARC32TO64_UAP(length);
2475 return (sys_truncate(p, &ua, retval));
2476 }
2477
2478 int
2479 compat_sparc32___sysctl(p, v, retval)
2480 struct proc *p;
2481 void *v;
2482 register_t *retval;
2483 {
2484 struct compat_sparc32___sysctl_args /* {
2485 syscallarg(sparc32_intp) name;
2486 syscallarg(u_int) namelen;
2487 syscallarg(sparc32_voidp) old;
2488 syscallarg(sparc32_size_tp) oldlenp;
2489 syscallarg(sparc32_voidp) new;
2490 syscallarg(sparc32_size_t) newlen;
2491 } */ *uap = v;
2492 struct sys___sysctl_args ua;
2493
2494 SPARC32TO64_UAP(namelen);
2495 SPARC32TOP_UAP(name, int);
2496 SPARC32TOP_UAP(old, void);
2497 SPARC32TOP_UAP(oldlenp, size_t);
2498 SPARC32TOP_UAP(new, void);
2499 SPARC32TOX_UAP(newlen, size_t);
2500 return (sys___sysctl(p, &ua, retval));
2501 }
2502
2503 int
2504 compat_sparc32_mlock(p, v, retval)
2505 struct proc *p;
2506 void *v;
2507 register_t *retval;
2508 {
2509 struct compat_sparc32_mlock_args /* {
2510 syscallarg(const sparc32_voidp) addr;
2511 syscallarg(sparc32_size_t) len;
2512 } */ *uap = v;
2513 struct sys_mlock_args ua;
2514
2515 SPARC32TOP_UAP(addr, const void);
2516 SPARC32TO64_UAP(len);
2517 return (sys_mlock(p, &ua, retval));
2518 }
2519
2520 int
2521 compat_sparc32_munlock(p, v, retval)
2522 struct proc *p;
2523 void *v;
2524 register_t *retval;
2525 {
2526 struct compat_sparc32_munlock_args /* {
2527 syscallarg(const sparc32_voidp) addr;
2528 syscallarg(sparc32_size_t) len;
2529 } */ *uap = v;
2530 struct sys_munlock_args ua;
2531
2532 SPARC32TOP_UAP(addr, const void);
2533 SPARC32TO64_UAP(len);
2534 return (sys_munlock(p, &ua, retval));
2535 }
2536
2537 int
2538 compat_sparc32_undelete(p, v, retval)
2539 struct proc *p;
2540 void *v;
2541 register_t *retval;
2542 {
2543 struct compat_sparc32_undelete_args /* {
2544 syscallarg(const sparc32_charp) path;
2545 } */ *uap = v;
2546 struct sys_undelete_args ua;
2547
2548 SPARC32TOP_UAP(path, const char);
2549 return (sys_undelete(p, &ua, retval));
2550 }
2551
2552 int
2553 compat_sparc32_futimes(p, v, retval)
2554 struct proc *p;
2555 void *v;
2556 register_t *retval;
2557 {
2558 struct compat_sparc32_futimes_args /* {
2559 syscallarg(int) fd;
2560 syscallarg(const sparc32_timevalp_t) tptr;
2561 } */ *uap = v;
2562 struct sys_futimes_args ua;
2563 struct timeval tv;
2564 struct sparc32_timeval *tv32p;
2565
2566 SPARC32TO64_UAP(fd);
2567 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
2568 if (tv32p) {
2569 SCARG(&ua, tptr) = &tv;
2570 sparc32_to_timeval(tv32p, &tv);
2571 } else
2572 SCARG(&ua, tptr) = NULL;
2573 return (sys_futimes(p, &ua, retval));
2574 }
2575
2576 int
2577 compat_sparc32_reboot(p, v, retval)
2578 struct proc *p;
2579 void *v;
2580 register_t *retval;
2581 {
2582 struct compat_sparc32_reboot_args /* {
2583 syscallarg(int) opt;
2584 syscallarg(sparc32_charp) bootstr;
2585 } */ *uap = v;
2586 struct sys_reboot_args ua;
2587
2588 SPARC32TO64_UAP(opt);
2589 SPARC32TOP_UAP(bootstr, char);
2590 return (sys_reboot(p, &ua, retval));
2591 }
2592
2593 int
2594 compat_sparc32_poll(p, v, retval)
2595 struct proc *p;
2596 void *v;
2597 register_t *retval;
2598 {
2599 struct compat_sparc32_poll_args /* {
2600 syscallarg(sparc32_pollfdp_t) fds;
2601 syscallarg(u_int) nfds;
2602 syscallarg(int) timeout;
2603 } */ *uap = v;
2604 struct sys_poll_args ua;
2605
2606 SPARC32TOP_UAP(fds, struct pollfd);
2607 SPARC32TO64_UAP(nfds);
2608 SPARC32TO64_UAP(timeout);
2609 return (sys_poll(p, &ua, retval));
2610 }
2611
2612 int
2613 compat_sparc32___semctl(p, v, retval)
2614 struct proc *p;
2615 void *v;
2616 register_t *retval;
2617 {
2618 struct compat_sparc32___semctl_args /* {
2619 syscallarg(int) semid;
2620 syscallarg(int) semnum;
2621 syscallarg(int) cmd;
2622 syscallarg(sparc32_semunu_t) arg;
2623 } */ *uap = v;
2624 struct sys___semctl_args ua;
2625 struct semid_ds ds, *dsp = &ds;
2626 union sparc32_semun *sem32p;
2627 int error;
2628
2629 SPARC32TO64_UAP(semid);
2630 SPARC32TO64_UAP(semnum);
2631 SPARC32TO64_UAP(cmd);
2632 sem32p = (union sparc32_semun *)(u_long)SCARG(uap, arg);
2633 if (sem32p) {
2634 SCARG(&ua, arg)->buf = dsp;
2635 switch (SCARG(uap, cmd)) {
2636 case IPC_SET:
2637 sparc32_to_semid_ds(sem32.buf, &ds);
2638 break;
2639 case SETVAL:
2640 SCARG(&ua, arg)->val = sem32.val;
2641 break;
2642 case SETALL:
2643 SCARG(&ua, arg)->array = (u_short *)(u_long)sem32.array;
2644 break;
2645 }
2646 } else
2647 SCARG(&ua, arg) = NULL;
2648
2649 error = sys___semctl(p, &ua, retval);
2650 if (error)
2651 return (error);
2652
2653 if (sem32p) {
2654 switch (SCARG(uap, cmd)) {
2655 case IPC_STAT:
2656 sparc32_from_semid_ds(&ds, sem32.buf);
2657 break;
2658 }
2659 }
2660 return (0);
2661 }
2662
2663 int
2664 compat_sparc32_semget(p, v, retval)
2665 struct proc *p;
2666 void *v;
2667 register_t *retval;
2668 {
2669 struct compat_sparc32_semget_args /* {
2670 syscallarg(sparc32_key_t) key;
2671 syscallarg(int) nsems;
2672 syscallarg(int) semflg;
2673 } */ *uap = v;
2674 struct sys_semget_args ua;
2675
2676 SPARC32TOX_UAP(key, key_t);
2677 SPARC32TO64_UAP(nsems);
2678 SPARC32TO64_UAP(semflg);
2679 return (sys_semget(p, &ua, retval));
2680 }
2681
2682 int
2683 compat_sparc32_semop(p, v, retval)
2684 struct proc *p;
2685 void *v;
2686 register_t *retval;
2687 {
2688 struct compat_sparc32_semop_args /* {
2689 syscallarg(int) semid;
2690 syscallarg(sparc32_sembufp_t) sops;
2691 syscallarg(sparc32_size_t) nsops;
2692 } */ *uap = v;
2693 struct sys_semop_args ua;
2694
2695 SPARC32TO64_UAP(semid);
2696 SPARC32TOP_UAP(sops, struct sembuf);
2697 SPARC32TOX_UAP(nsops, size_t);
2698 return (sys_semop(p, &ua, retval));
2699 }
2700
2701 int
2702 compat_sparc32_msgctl(p, v, retval)
2703 struct proc *p;
2704 void *v;
2705 register_t *retval;
2706 {
2707 struct compat_sparc32_msgctl_args /* {
2708 syscallarg(int) msqid;
2709 syscallarg(int) cmd;
2710 syscallarg(sparc32_msqid_dsp_t) buf;
2711 } */ *uap = v;
2712 struct sys_msgctl_args ua;
2713 struct msqid_ds ds;
2714 struct sparc32_msqid_ds *ds32p;
2715 int error;
2716
2717 SPARC32TO64_UAP(msqid);
2718 SPARC32TO64_UAP(cmd);
2719 ds32p = (struct sparc32_msqid_ds *)(u_long)SCARG(uap, buf);
2720 if (ds32p) {
2721 SCARG(&ua, buf) = NULL;
2722 sparc32_to_msqid_ds(ds32p, &ds);
2723 } else
2724 SCARG(&ua, buf) = NULL;
2725 error = sys_msgctl(p, &ua, retval);
2726 if (error)
2727 return (error);
2728
2729 if (ds32p)
2730 sparc32_from_msqid_ds(&ds, ds32p);
2731 return (0);
2732 }
2733
2734 int
2735 compat_sparc32_msgget(p, v, retval)
2736 struct proc *p;
2737 void *v;
2738 register_t *retval;
2739 {
2740 struct compat_sparc32_msgget_args /* {
2741 syscallarg(sparc32_key_t) key;
2742 syscallarg(int) msgflg;
2743 } */ *uap = v;
2744 struct sys_msgget_args ua;
2745
2746 SPARC32TOX_UAP(key, key_t);
2747 SPARC32TO64_UAP(msgflg);
2748 return (sys_msgget(p, &ua, retval));
2749 }
2750
2751 int
2752 compat_sparc32_msgsnd(p, v, retval)
2753 struct proc *p;
2754 void *v;
2755 register_t *retval;
2756 {
2757 struct compat_sparc32_msgsnd_args /* {
2758 syscallarg(int) msqid;
2759 syscallarg(const sparc32_voidp) msgp;
2760 syscallarg(sparc32_size_t) msgsz;
2761 syscallarg(int) msgflg;
2762 } */ *uap = v;
2763 struct sys_msgsnd_args ua;
2764
2765 SPARC32TO64_UAP(msqid);
2766 SPARC32TOP_UAP(msgp, void);
2767 SPARC32TOX_UAP(msgsz, size_t);
2768 SPARC32TO64_UAP(msgflg);
2769 return (sys_msgsnd(p, &ua, retval));
2770 }
2771
2772 int
2773 compat_sparc32_msgrcv(p, v, retval)
2774 struct proc *p;
2775 void *v;
2776 register_t *retval;
2777 {
2778 struct compat_sparc32_msgrcv_args /* {
2779 syscallarg(int) msqid;
2780 syscallarg(sparc32_voidp) msgp;
2781 syscallarg(sparc32_size_t) msgsz;
2782 syscallarg(sparc32_long) msgtyp;
2783 syscallarg(int) msgflg;
2784 } */ *uap = v;
2785 struct sys_msgrcv_args ua;
2786 ssize_t rt;
2787 int error;
2788
2789 SPARC32TO64_UAP(msqid);
2790 SPARC32TOP_UAP(msgp, void);
2791 SPARC32TOX_UAP(msgsz, size_t);
2792 SPARC32TOX_UAP(msgtyp, long);
2793 SPARC32TO64_UAP(msgflg);
2794 error = sys_msgrcv(p, &ua, (register_t *)&rt);
2795 *(sparc32_ssize_t *)retval = rt;
2796 return (error);
2797 }
2798
2799 int
2800 compat_sparc32_shmat(p, v, retval)
2801 struct proc *p;
2802 void *v;
2803 register_t *retval;
2804 {
2805 struct compat_sparc32_shmat_args /* {
2806 syscallarg(int) shmid;
2807 syscallarg(const sparc32_voidp) shmaddr;
2808 syscallarg(int) shmflg;
2809 } */ *uap = v;
2810 struct sys_shmat_args ua;
2811 void *rt;
2812 int error;
2813
2814 SPARC32TO64_UAP(shmid);
2815 SPARC32TOP_UAP(shmaddr, void);
2816 SPARC32TO64_UAP(shmflg);
2817 error = sys_shmat(p, &ua, (register_t *)&rt);
2818 *retval = (sparc32_voidp)(u_long)rt;
2819 return (error);
2820 }
2821
2822 int
2823 compat_sparc32_shmctl(p, v, retval)
2824 struct proc *p;
2825 void *v;
2826 register_t *retval;
2827 {
2828 struct compat_sparc32_shmctl_args /* {
2829 syscallarg(int) shmid;
2830 syscallarg(int) cmd;
2831 syscallarg(sparc32_shmid_dsp_t) buf;
2832 } */ *uap = v;
2833 struct sys_shmctl_args ua;
2834 struct shmid_ds ds;
2835 struct sparc32_shmid_ds *ds32p;
2836 int error;
2837
2838 SPARC32TO64_UAP(shmid);
2839 SPARC32TO64_UAP(cmd);
2840 ds32p = (struct sparc32_shmid_ds *)(u_long)SCARG(uap, buf);
2841 if (ds32p) {
2842 SCARG(&ua, buf) = NULL;
2843 sparc32_to_shmid_ds(ds32p, &ds);
2844 } else
2845 SCARG(&ua, buf) = NULL;
2846 error = sys_shmctl(p, &ua, retval);
2847 if (error)
2848 return (error);
2849
2850 if (ds32p)
2851 sparc32_from_shmid_ds(&ds, ds32p);
2852 return (0);
2853 }
2854
2855 int
2856 compat_sparc32_shmdt(p, v, retval)
2857 struct proc *p;
2858 void *v;
2859 register_t *retval;
2860 {
2861 struct compat_sparc32_shmdt_args /* {
2862 syscallarg(const sparc32_voidp) shmaddr;
2863 } */ *uap = v;
2864 struct sys_shmdt_args ua;
2865
2866 SPARC32TOP_UAP(shmaddr, const char);
2867 return (sys_shmdt(p, &ua, retval));
2868 }
2869
2870 int
2871 compat_sparc32_shmget(p, v, retval)
2872 struct proc *p;
2873 void *v;
2874 register_t *retval;
2875 {
2876 struct compat_sparc32_shmget_args /* {
2877 syscallarg(sparc32_key_t) key;
2878 syscallarg(sparc32_size_t) size;
2879 syscallarg(int) shmflg;
2880 } */ *uap = v;
2881 struct sys_shmget_args ua;
2882
2883 SPARC32TOX_UAP(key, key_t)
2884 SPARC32TOX_UAP(size, size_t)
2885 SPARC32TO64_UAP(shmflg);
2886 return (sys_shmget(p, &ua, retval));
2887 }
2888
2889 int
2890 compat_sparc32_clock_gettime(p, v, retval)
2891 struct proc *p;
2892 void *v;
2893 register_t *retval;
2894 {
2895 struct compat_sparc32_clock_gettime_args /* {
2896 syscallarg(sparc32_clockid_t) clock_id;
2897 syscallarg(sparc32_timespecp_t) tp;
2898 } */ *uap = v;
2899 struct sys_clock_gettime_args ua;
2900 struct timespec ts;
2901 struct sparc32_timespec *ts32p;
2902 int error;
2903
2904 SPARC32TO64_UAP(clock_id);
2905 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
2906 if (ts32p)
2907 SCARG(&ua, tp) = &ts;
2908 else
2909 SCARG(&ua, tp) = NULL;
2910 error = sys_clock_gettime(p, &ua, retval);
2911 if (error)
2912 return (error);
2913
2914 if (ts32p)
2915 sparc32_from_timespec(&ts, ts32p);
2916 return (0);
2917 }
2918
2919 int
2920 compat_sparc32_clock_settime(p, v, retval)
2921 struct proc *p;
2922 void *v;
2923 register_t *retval;
2924 {
2925 struct compat_sparc32_clock_settime_args /* {
2926 syscallarg(sparc32_clockid_t) clock_id;
2927 syscallarg(const sparc32_timespecp_t) tp;
2928 } */ *uap = v;
2929 struct sys_clock_settime_args ua;
2930 struct timespec ts;
2931 struct sparc32_timespec *ts32p;
2932
2933 SPARC32TO64_UAP(clock_id);
2934 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
2935 if (ts32p) {
2936 SCARG(&ua, tp) = &ts;
2937 sparc32_to_timespec(ts32p, &ts);
2938 } else
2939 SCARG(&ua, tp) = NULL;
2940 return (sys_clock_settime(p, &ua, retval));
2941 }
2942
2943 int
2944 compat_sparc32_clock_getres(p, v, retval)
2945 struct proc *p;
2946 void *v;
2947 register_t *retval;
2948 {
2949 struct compat_sparc32_clock_getres_args /* {
2950 syscallarg(sparc32_clockid_t) clock_id;
2951 syscallarg(sparc32_timespecp_t) tp;
2952 } */ *uap = v;
2953 struct sys_clock_getres_args ua;
2954 struct timespec ts;
2955 struct sparc32_timespec *ts32p;
2956 int error;
2957
2958 SPARC32TO64_UAP(clock_id);
2959 ts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, tp);
2960 if (ts32p)
2961 SCARG(&ua, tp) = &ts;
2962 else
2963 SCARG(&ua, tp) = NULL;
2964 error = sys_clock_getres(p, &ua, retval);
2965 if (error)
2966 return (error);
2967
2968 if (ts32p)
2969 sparc32_from_timespec(&ts, ts32p);
2970 return (0);
2971 }
2972
2973 int
2974 compat_sparc32_nanosleep(p, v, retval)
2975 struct proc *p;
2976 void *v;
2977 register_t *retval;
2978 {
2979 struct compat_sparc32_nanosleep_args /* {
2980 syscallarg(const sparc32_timespecp_t) rqtp;
2981 syscallarg(sparc32_timespecp_t) rmtp;
2982 } */ *uap = v;
2983 struct sys_nanosleep_args ua;
2984 struct timespec qts, mts;
2985 struct sparc32_timespec *qts32p, *mts32p;
2986 int error;
2987
2988 qts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rqtp);
2989 mts32p = (struct sparc32_timespec *)(u_long)SCARG(uap, rmtp);
2990 if (qts32p) {
2991 SCARG(&ua, rqtp) = &qts;
2992 sparc32_to_timespec(qts32p, &qts);
2993 } else
2994 SCARG(&ua, rqtp) = NULL;
2995 if (mts32p) {
2996 SCARG(&ua, rmtp) = &mts;
2997 } else
2998 SCARG(&ua, rmtp) = NULL;
2999 error = sys_nanosleep(p, &ua, retval);
3000 if (error)
3001 return (error);
3002
3003 if (mts32p)
3004 sparc32_from_timespec(&mts, mts32p);
3005 return (0);
3006 }
3007
3008 int
3009 compat_sparc32___posix_rename(p, v, retval)
3010 struct proc *p;
3011 void *v;
3012 register_t *retval;
3013 {
3014 struct compat_sparc32___posix_rename_args /* {
3015 syscallarg(const sparc32_charp) from;
3016 syscallarg(const sparc32_charp) to;
3017 } */ *uap = v;
3018 struct sys___posix_rename_args ua;
3019
3020 SPARC32TOP_UAP(from, const char)
3021 SPARC32TOP_UAP(to, const char)
3022 return (sys___posix_rename(p, &ua, retval));
3023 }
3024
3025 int
3026 compat_sparc32_swapctl(p, v, retval)
3027 struct proc *p;
3028 void *v;
3029 register_t *retval;
3030 {
3031 struct compat_sparc32_swapctl_args /* {
3032 syscallarg(int) cmd;
3033 syscallarg(const sparc32_voidp) arg;
3034 syscallarg(int) misc;
3035 } */ *uap = v;
3036 struct sys_swapctl_args ua;
3037
3038 SPARC32TO64_UAP(cmd);
3039 SPARC32TOP_UAP(arg, const void);
3040 SPARC32TO64_UAP(misc);
3041 return (sys_swapctl(p, &ua, retval));
3042 }
3043
3044 int
3045 compat_sparc32_getdents(p, v, retval)
3046 struct proc *p;
3047 void *v;
3048 register_t *retval;
3049 {
3050 struct compat_sparc32_getdents_args /* {
3051 syscallarg(int) fd;
3052 syscallarg(sparc32_charp) buf;
3053 syscallarg(sparc32_size_t) count;
3054 } */ *uap = v;
3055 struct sys_getdents_args ua;
3056
3057 SPARC32TO64_UAP(fd);
3058 SPARC32TOP_UAP(buf, char);
3059 SPARC32TOX_UAP(count, size_t);
3060 return (sys_getdents(p, &ua, retval));
3061 }
3062
3063 int
3064 compat_sparc32_minherit(p, v, retval)
3065 struct proc *p;
3066 void *v;
3067 register_t *retval;
3068 {
3069 struct compat_sparc32_minherit_args /* {
3070 syscallarg(sparc32_voidp) addr;
3071 syscallarg(sparc32_size_t) len;
3072 syscallarg(int) inherit;
3073 } */ *uap = v;
3074 struct sys_minherit_args ua;
3075
3076 SPARC32TOP_UAP(addr, void);
3077 SPARC32TOX_UAP(len, size_t);
3078 SPARC32TO64_UAP(inherit);
3079 return (sys_minherit(p, &ua, retval));
3080 }
3081
3082 int
3083 compat_sparc32_lchmod(p, v, retval)
3084 struct proc *p;
3085 void *v;
3086 register_t *retval;
3087 {
3088 struct compat_sparc32_lchmod_args /* {
3089 syscallarg(const sparc32_charp) path;
3090 syscallarg(mode_t) mode;
3091 } */ *uap = v;
3092 struct sys_lchmod_args ua;
3093
3094 SPARC32TOP_UAP(path, const char);
3095 SPARC32TO64_UAP(mode);
3096 return (sys_lchmod(p, &ua, retval));
3097 }
3098
3099 int
3100 compat_sparc32_lchown(p, v, retval)
3101 struct proc *p;
3102 void *v;
3103 register_t *retval;
3104 {
3105 struct compat_sparc32_lchown_args /* {
3106 syscallarg(const sparc32_charp) path;
3107 syscallarg(uid_t) uid;
3108 syscallarg(gid_t) gid;
3109 } */ *uap = v;
3110 struct sys_lchown_args ua;
3111
3112 SPARC32TOP_UAP(path, const char);
3113 SPARC32TO64_UAP(uid);
3114 SPARC32TO64_UAP(gid);
3115 return (sys_lchown(p, &ua, retval));
3116 }
3117
3118 int
3119 compat_sparc32_lutimes(p, v, retval)
3120 struct proc *p;
3121 void *v;
3122 register_t *retval;
3123 {
3124 struct compat_sparc32_lutimes_args /* {
3125 syscallarg(const sparc32_charp) path;
3126 syscallarg(const sparc32_timevalp_t) tptr;
3127 } */ *uap = v;
3128 struct sys_lutimes_args ua;
3129 struct timeval tv;
3130 struct sparc32_timeval *tv32p;
3131
3132 SPARC32TOP_UAP(path, const char);
3133 tv32p = (struct sparc32_timeval *)(u_long)SCARG(uap, tptr);
3134 if (tv32p) {
3135 SCARG(&ua, tptr) = &tv;
3136 sparc32_to_timeval(tv32p, &tv);
3137 }
3138 SCARG(&ua, tptr) = NULL;
3139 return (sys_lutimes(p, &ua, retval));
3140 }
3141
3142 int
3143 compat_sparc32___msync13(p, v, retval)
3144 struct proc *p;
3145 void *v;
3146 register_t *retval;
3147 {
3148 struct compat_sparc32___msync13_args /* {
3149 syscallarg(sparc32_voidp) addr;
3150 syscallarg(sparc32_size_t) len;
3151 syscallarg(int) flags;
3152 } */ *uap = v;
3153 struct sys___msync13_args ua;
3154
3155 SPARC32TOP_UAP(addr, void);
3156 SPARC32TOX_UAP(len, size_t);
3157 SPARC32TO64_UAP(flags);
3158 return (sys___msync13(p, &ua, retval));
3159 }
3160
3161 int
3162 compat_sparc32___stat13(p, v, retval)
3163 struct proc *p;
3164 void *v;
3165 register_t *retval;
3166 {
3167 struct compat_sparc32___stat13_args /* {
3168 syscallarg(const sparc32_charp) path;
3169 syscallarg(sparc32_statp_t) ub;
3170 } */ *uap = v;
3171 struct sys___stat13_args ua;
3172 struct stat sb;
3173 struct sparc32_stat *sb32p;
3174 caddr_t sg;
3175 int error;
3176
3177 SPARC32TOP_UAP(path, const char);
3178 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub);
3179 if (sb32p)
3180 SCARG(&ua, ub) = &sb;
3181 else
3182 SCARG(&ua, ub) = NULL;
3183 sg = stackgap_init(p->p_emul);
3184 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
3185
3186 error = sys___stat13(p, &ua, retval);
3187 if (error)
3188 return (error);
3189
3190 if (sb32p)
3191 sparc32_from___stat13(&sb, sb32p);
3192 return (0);
3193 }
3194
3195 int
3196 compat_sparc32___fstat13(p, v, retval)
3197 struct proc *p;
3198 void *v;
3199 register_t *retval;
3200 {
3201 struct compat_sparc32___fstat13_args /* {
3202 syscallarg(int) fd;
3203 syscallarg(sparc32_statp_t) sb;
3204 } */ *uap = v;
3205 struct sys___fstat13_args ua;
3206 struct stat sb;
3207 struct sparc32_stat *sb32p;
3208 int error;
3209
3210 SPARC32TO64_UAP(fd);
3211 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, sb);
3212 if (sb32p)
3213 SCARG(&ua, sb) = &sb;
3214 else
3215 SCARG(&ua, sb) = NULL;
3216 error = sys___fstat13(p, &ua, retval);
3217 if (error)
3218 return (error);
3219
3220 if (sb32p)
3221 sparc32_from___stat13(&sb, sb32p);
3222 return (0);
3223 }
3224
3225 int
3226 compat_sparc32___lstat13(p, v, retval)
3227 struct proc *p;
3228 void *v;
3229 register_t *retval;
3230 {
3231 struct compat_sparc32___lstat13_args /* {
3232 syscallarg(const sparc32_charp) path;
3233 syscallarg(sparc32_statp_t) ub;
3234 } */ *uap = v;
3235
3236 struct sys___lstat13_args ua;
3237 struct stat sb;
3238 struct sparc32_stat *sb32p;
3239 caddr_t sg;
3240 int error;
3241
3242 SPARC32TOP_UAP(path, const char);
3243 sb32p = (struct sparc32_stat *)(u_long)SCARG(uap, ub);
3244 if (sb32p)
3245 SCARG(&ua, ub) = &sb;
3246 else
3247 SCARG(&ua, ub) = NULL;
3248 sg = stackgap_init(p->p_emul);
3249 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path));
3250 error = sys___lstat13(p, &ua, retval);
3251 if (error)
3252 return (error);
3253
3254 if (sb32p)
3255 sparc32_from___stat13(&sb, sb32p);
3256 return (0);
3257 }
3258
3259 int
3260 compat_sparc32___sigaltstack14(p, v, retval)
3261 struct proc *p;
3262 void *v;
3263 register_t *retval;
3264 {
3265 struct compat_sparc32___sigaltstack14_args /* {
3266 syscallarg(const sparc32_sigaltstackp_t) nss;
3267 syscallarg(sparc32_sigaltstackp_t) oss;
3268 } */ *uap = v;
3269 struct sys___sigaltstack14_args ua;
3270 struct sparc32_sigaltstack *nss32, *oss32;
3271 struct sigaltstack nss, oss;
3272 int error;
3273
3274 nss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, nss);
3275 oss32 = (struct sparc32_sigaltstack *)(u_long)SCARG(uap, oss);
3276 if (nss32) {
3277 SCARG(&ua, nss) = &nss;
3278 nss.ss_sp = (void *)(u_long)nss32->ss_sp;
3279 nss.ss_size = (size_t)nss32->ss_size;
3280 nss.ss_flags = nss32->ss_flags;
3281 } else
3282 SCARG(&ua, nss) = NULL;
3283 if (oss32)
3284 SCARG(&ua, oss) = &oss;
3285 else
3286 SCARG(&ua, oss) = NULL;
3287
3288 error = sys___sigaltstack14(p, &ua, retval);
3289 if (error)
3290 return (error);
3291
3292 if (oss32) {
3293 oss32->ss_sp = (sparc32_voidp)(u_long)oss.ss_sp;
3294 oss32->ss_size = (sparc32_size_t)oss.ss_size;
3295 oss32->ss_flags = oss.ss_flags;
3296 }
3297 return (0);
3298 }
3299
3300 int
3301 compat_sparc32___posix_chown(p, v, retval)
3302 struct proc *p;
3303 void *v;
3304 register_t *retval;
3305 {
3306 struct compat_sparc32___posix_chown_args /* {
3307 syscallarg(const sparc32_charp) path;
3308 syscallarg(uid_t) uid;
3309 syscallarg(gid_t) gid;
3310 } */ *uap = v;
3311 struct sys___posix_chown_args ua;
3312
3313 SPARC32TOP_UAP(path, const char);
3314 SPARC32TO64_UAP(uid);
3315 SPARC32TO64_UAP(gid);
3316 return (sys___posix_chown(p, &ua, retval));
3317 }
3318
3319 int
3320 compat_sparc32___posix_lchown(p, v, retval)
3321 struct proc *p;
3322 void *v;
3323 register_t *retval;
3324 {
3325 struct compat_sparc32___posix_lchown_args /* {
3326 syscallarg(const sparc32_charp) path;
3327 syscallarg(uid_t) uid;
3328 syscallarg(gid_t) gid;
3329 } */ *uap = v;
3330 struct sys___posix_lchown_args ua;
3331
3332 SPARC32TOP_UAP(path, const char);
3333 SPARC32TO64_UAP(uid);
3334 SPARC32TO64_UAP(gid);
3335 return (sys___posix_lchown(p, &ua, retval));
3336 }
3337
3338 int
3339 compat_sparc32_preadv(p, v, retval)
3340 struct proc *p;
3341 void *v;
3342 register_t *retval;
3343 {
3344 struct compat_sparc32_preadv_args /* {
3345 syscallarg(int) fd;
3346 syscallarg(const sparc32_iovecp_t) iovp;
3347 syscallarg(int) iovcnt;
3348 syscallarg(int) pad;
3349 syscallarg(off_t) offset;
3350 } */ *uap = v;
3351 struct sys_preadv_args ua;
3352 struct iovec *iov;
3353 ssize_t rt;
3354 int error;
3355
3356 SPARC32TO64_UAP(fd);
3357 SPARC32TO64_UAP(iovcnt);
3358 SPARC32TO64_UAP(pad);
3359 SPARC32TO64_UAP(offset);
3360 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
3361 M_TEMP, M_WAITOK);
3362 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
3363 SCARG(uap, iovcnt));
3364 SCARG(&ua, iovp) = iov;
3365
3366 error = sys_preadv(p, &ua, (register_t *)&rt);
3367 FREE(iov, M_TEMP);
3368 *(sparc32_ssize_t *)retval = rt;
3369 return (error);
3370 }
3371
3372 int
3373 compat_sparc32_pwritev(p, v, retval)
3374 struct proc *p;
3375 void *v;
3376 register_t *retval;
3377 {
3378 struct compat_sparc32_pwritev_args /* {
3379 syscallarg(int) fd;
3380 syscallarg(const sparc32_iovecp_t) iovp;
3381 syscallarg(int) iovcnt;
3382 syscallarg(int) pad;
3383 syscallarg(off_t) offset;
3384 } */ *uap = v;
3385 struct sys_pwritev_args ua;
3386 struct iovec *iov;
3387 ssize_t rt;
3388 int error;
3389
3390 SPARC32TO64_UAP(fd);
3391 SPARC32TO64_UAP(iovcnt);
3392 SPARC32TO64_UAP(pad);
3393 SPARC32TO64_UAP(offset);
3394 MALLOC(iov, struct iovec *, sizeof(struct iovec) * SCARG(uap, iovcnt),
3395 M_TEMP, M_WAITOK);
3396 sparc32_to_iovec((struct sparc32_iovec *)(u_long)SCARG(uap, iovp), iov,
3397 SCARG(uap, iovcnt));
3398 SCARG(&ua, iovp) = iov;
3399
3400 error = sys_pwritev(p, &ua, (register_t *)&rt);
3401 FREE(iov, M_TEMP);
3402 *(sparc32_ssize_t *)retval = rt;
3403 return (error);
3404 }
3405