1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2002 Doug Rabson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include "opt_ffclock.h"
33 #include "opt_inet.h"
34 #include "opt_inet6.h"
35 #include "opt_ktrace.h"
36
37 #define __ELF_WORD_SIZE 32
38
39 #ifdef COMPAT_FREEBSD11
40 #define _WANT_FREEBSD11_KEVENT
41 #endif
42
43 #include <sys/param.h>
44 #include <sys/bus.h>
45 #include <sys/capsicum.h>
46 #include <sys/clock.h>
47 #include <sys/exec.h>
48 #include <sys/fcntl.h>
49 #include <sys/filedesc.h>
50 #include <sys/imgact.h>
51 #include <sys/jail.h>
52 #include <sys/kernel.h>
53 #include <sys/limits.h>
54 #include <sys/linker.h>
55 #include <sys/lock.h>
56 #include <sys/malloc.h>
57 #include <sys/file.h> /* Must come after sys/malloc.h */
58 #include <sys/imgact.h>
59 #include <sys/mbuf.h>
60 #include <sys/mman.h>
61 #include <sys/module.h>
62 #include <sys/mount.h>
63 #include <sys/mutex.h>
64 #include <sys/namei.h>
65 #include <sys/priv.h>
66 #include <sys/proc.h>
67 #include <sys/procctl.h>
68 #include <sys/ptrace.h>
69 #include <sys/reboot.h>
70 #include <sys/resource.h>
71 #include <sys/resourcevar.h>
72 #include <sys/selinfo.h>
73 #include <sys/eventvar.h> /* Must come after sys/selinfo.h */
74 #include <sys/pipe.h> /* Must come after sys/selinfo.h */
75 #include <sys/signal.h>
76 #include <sys/signalvar.h>
77 #include <sys/socket.h>
78 #include <sys/socketvar.h>
79 #include <sys/stat.h>
80 #include <sys/syscall.h>
81 #include <sys/syscallsubr.h>
82 #include <sys/sysctl.h>
83 #include <sys/sysent.h>
84 #include <sys/sysproto.h>
85 #include <sys/systm.h>
86 #include <sys/thr.h>
87 #include <sys/timex.h>
88 #include <sys/unistd.h>
89 #include <sys/ucontext.h>
90 #include <sys/vnode.h>
91 #include <sys/wait.h>
92 #include <sys/ipc.h>
93 #include <sys/msg.h>
94 #include <sys/sem.h>
95 #include <sys/shm.h>
96 #include <sys/timeffc.h>
97 #ifdef KTRACE
98 #include <sys/ktrace.h>
99 #endif
100
101 #ifdef INET
102 #include <netinet/in.h>
103 #endif
104
105 #include <vm/vm.h>
106 #include <vm/vm_param.h>
107 #include <vm/pmap.h>
108 #include <vm/vm_map.h>
109 #include <vm/vm_object.h>
110 #include <vm/vm_extern.h>
111
112 #include <machine/cpu.h>
113 #include <machine/elf.h>
114 #ifdef __amd64__
115 #include <machine/md_var.h>
116 #endif
117
118 #include <security/audit/audit.h>
119
120 #include <compat/freebsd32/freebsd32_util.h>
121 #include <compat/freebsd32/freebsd32.h>
122 #include <compat/freebsd32/freebsd32_ipc.h>
123 #include <compat/freebsd32/freebsd32_misc.h>
124 #include <compat/freebsd32/freebsd32_signal.h>
125 #include <compat/freebsd32/freebsd32_proto.h>
126
127 FEATURE(compat_freebsd_32bit, "Compatible with 32-bit FreeBSD");
128
129 struct ptrace_io_desc32 {
130 int piod_op;
131 uint32_t piod_offs;
132 uint32_t piod_addr;
133 uint32_t piod_len;
134 };
135
136 struct ptrace_vm_entry32 {
137 int pve_entry;
138 int pve_timestamp;
139 uint32_t pve_start;
140 uint32_t pve_end;
141 uint32_t pve_offset;
142 u_int pve_prot;
143 u_int pve_pathlen;
144 int32_t pve_fileid;
145 u_int pve_fsid;
146 uint32_t pve_path;
147 };
148
149 #ifdef __amd64__
150 CTASSERT(sizeof(struct timeval32) == 8);
151 CTASSERT(sizeof(struct timespec32) == 8);
152 CTASSERT(sizeof(struct itimerval32) == 16);
153 CTASSERT(sizeof(struct bintime32) == 12);
154 #else
155 CTASSERT(sizeof(struct timeval32) == 16);
156 CTASSERT(sizeof(struct timespec32) == 16);
157 CTASSERT(sizeof(struct itimerval32) == 32);
158 CTASSERT(sizeof(struct bintime32) == 16);
159 #endif
160 CTASSERT(sizeof(struct ostatfs32) == 256);
161 #ifdef __amd64__
162 CTASSERT(sizeof(struct rusage32) == 72);
163 #else
164 CTASSERT(sizeof(struct rusage32) == 88);
165 #endif
166 CTASSERT(sizeof(struct sigaltstack32) == 12);
167 #ifdef __amd64__
168 CTASSERT(sizeof(struct kevent32) == 56);
169 #else
170 CTASSERT(sizeof(struct kevent32) == 64);
171 #endif
172 CTASSERT(sizeof(struct iovec32) == 8);
173 CTASSERT(sizeof(struct msghdr32) == 28);
174 #ifdef __amd64__
175 CTASSERT(sizeof(struct stat32) == 208);
176 CTASSERT(sizeof(struct freebsd11_stat32) == 96);
177 #else
178 CTASSERT(sizeof(struct stat32) == 224);
179 CTASSERT(sizeof(struct freebsd11_stat32) == 120);
180 #endif
181 CTASSERT(sizeof(struct sigaction32) == 24);
182
183 static int freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count);
184 static int freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count);
185 static int freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id,
186 int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp);
187
188 void
189 freebsd32_rusage_out(const struct rusage *s, struct rusage32 *s32)
190 {
191
192 TV_CP(*s, *s32, ru_utime);
193 TV_CP(*s, *s32, ru_stime);
194 CP(*s, *s32, ru_maxrss);
195 CP(*s, *s32, ru_ixrss);
196 CP(*s, *s32, ru_idrss);
197 CP(*s, *s32, ru_isrss);
198 CP(*s, *s32, ru_minflt);
199 CP(*s, *s32, ru_majflt);
200 CP(*s, *s32, ru_nswap);
201 CP(*s, *s32, ru_inblock);
202 CP(*s, *s32, ru_oublock);
203 CP(*s, *s32, ru_msgsnd);
204 CP(*s, *s32, ru_msgrcv);
205 CP(*s, *s32, ru_nsignals);
206 CP(*s, *s32, ru_nvcsw);
207 CP(*s, *s32, ru_nivcsw);
208 }
209
210 int
211 freebsd32_wait4(struct thread *td, struct freebsd32_wait4_args *uap)
212 {
213 int error, status;
214 struct rusage32 ru32;
215 struct rusage ru, *rup;
216
217 if (uap->rusage != NULL)
218 rup = &ru;
219 else
220 rup = NULL;
221 error = kern_wait(td, uap->pid, &status, uap->options, rup);
222 if (error)
223 return (error);
224 if (uap->status != NULL)
225 error = copyout(&status, uap->status, sizeof(status));
226 if (uap->rusage != NULL && error == 0) {
227 freebsd32_rusage_out(&ru, &ru32);
228 error = copyout(&ru32, uap->rusage, sizeof(ru32));
229 }
230 return (error);
231 }
232
233 int
234 freebsd32_wait6(struct thread *td, struct freebsd32_wait6_args *uap)
235 {
236 struct __wrusage32 wru32;
237 struct __wrusage wru, *wrup;
238 struct siginfo32 si32;
239 struct __siginfo si, *sip;
240 int error, status;
241
242 if (uap->wrusage != NULL)
243 wrup = &wru;
244 else
245 wrup = NULL;
246 if (uap->info != NULL) {
247 sip = &si;
248 bzero(sip, sizeof(*sip));
249 } else
250 sip = NULL;
251 error = kern_wait6(td, uap->idtype, PAIR32TO64(id_t, uap->id),
252 &status, uap->options, wrup, sip);
253 if (error != 0)
254 return (error);
255 if (uap->status != NULL)
256 error = copyout(&status, uap->status, sizeof(status));
257 if (uap->wrusage != NULL && error == 0) {
258 freebsd32_rusage_out(&wru.wru_self, &wru32.wru_self);
259 freebsd32_rusage_out(&wru.wru_children, &wru32.wru_children);
260 error = copyout(&wru32, uap->wrusage, sizeof(wru32));
261 }
262 if (uap->info != NULL && error == 0) {
263 siginfo_to_siginfo32 (&si, &si32);
264 error = copyout(&si32, uap->info, sizeof(si32));
265 }
266 return (error);
267 }
268
269 #ifdef COMPAT_FREEBSD4
270 static void
271 copy_statfs(struct statfs *in, struct ostatfs32 *out)
272 {
273
274 statfs_scale_blocks(in, INT32_MAX);
275 bzero(out, sizeof(*out));
276 CP(*in, *out, f_bsize);
277 out->f_iosize = MIN(in->f_iosize, INT32_MAX);
278 CP(*in, *out, f_blocks);
279 CP(*in, *out, f_bfree);
280 CP(*in, *out, f_bavail);
281 out->f_files = MIN(in->f_files, INT32_MAX);
282 out->f_ffree = MIN(in->f_ffree, INT32_MAX);
283 CP(*in, *out, f_fsid);
284 CP(*in, *out, f_owner);
285 CP(*in, *out, f_type);
286 CP(*in, *out, f_flags);
287 out->f_syncwrites = MIN(in->f_syncwrites, INT32_MAX);
288 out->f_asyncwrites = MIN(in->f_asyncwrites, INT32_MAX);
289 strlcpy(out->f_fstypename,
290 in->f_fstypename, MFSNAMELEN);
291 strlcpy(out->f_mntonname,
292 in->f_mntonname, min(MNAMELEN, FREEBSD4_OMNAMELEN));
293 out->f_syncreads = MIN(in->f_syncreads, INT32_MAX);
294 out->f_asyncreads = MIN(in->f_asyncreads, INT32_MAX);
295 strlcpy(out->f_mntfromname,
296 in->f_mntfromname, min(MNAMELEN, FREEBSD4_OMNAMELEN));
297 }
298 #endif
299
300 int
301 freebsd32_getfsstat(struct thread *td, struct freebsd32_getfsstat_args *uap)
302 {
303 size_t count;
304 int error;
305
306 if (uap->bufsize < 0 || uap->bufsize > SIZE_MAX)
307 return (EINVAL);
308 error = kern_getfsstat(td, &uap->buf, uap->bufsize, &count,
309 UIO_USERSPACE, uap->mode);
310 if (error == 0)
311 td->td_retval[0] = count;
312 return (error);
313 }
314
315 #ifdef COMPAT_FREEBSD4
316 int
317 freebsd4_freebsd32_getfsstat(struct thread *td,
318 struct freebsd4_freebsd32_getfsstat_args *uap)
319 {
320 struct statfs *buf, *sp;
321 struct ostatfs32 stat32;
322 size_t count, size, copycount;
323 int error;
324
325 count = uap->bufsize / sizeof(struct ostatfs32);
326 size = count * sizeof(struct statfs);
327 error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE, uap->mode);
328 if (size > 0) {
329 sp = buf;
330 copycount = count;
331 while (copycount > 0 && error == 0) {
332 copy_statfs(sp, &stat32);
333 error = copyout(&stat32, uap->buf, sizeof(stat32));
334 sp++;
335 uap->buf++;
336 copycount--;
337 }
338 free(buf, M_STATFS);
339 }
340 if (error == 0)
341 td->td_retval[0] = count;
342 return (error);
343 }
344 #endif
345
346 #ifdef COMPAT_FREEBSD11
347 int
348 freebsd11_freebsd32_getfsstat(struct thread *td,
349 struct freebsd11_freebsd32_getfsstat_args *uap)
350 {
351 return(kern_freebsd11_getfsstat(td, uap->buf, uap->bufsize,
352 uap->mode));
353 }
354 #endif
355
356 int
357 freebsd32_sigaltstack(struct thread *td,
358 struct freebsd32_sigaltstack_args *uap)
359 {
360 struct sigaltstack32 s32;
361 struct sigaltstack ss, oss, *ssp;
362 int error;
363
364 if (uap->ss != NULL) {
365 error = copyin(uap->ss, &s32, sizeof(s32));
366 if (error)
367 return (error);
368 PTRIN_CP(s32, ss, ss_sp);
369 CP(s32, ss, ss_size);
370 CP(s32, ss, ss_flags);
371 ssp = &ss;
372 } else
373 ssp = NULL;
374 error = kern_sigaltstack(td, ssp, &oss);
375 if (error == 0 && uap->oss != NULL) {
376 PTROUT_CP(oss, s32, ss_sp);
377 CP(oss, s32, ss_size);
378 CP(oss, s32, ss_flags);
379 error = copyout(&s32, uap->oss, sizeof(s32));
380 }
381 return (error);
382 }
383
384 /*
385 * Custom version of exec_copyin_args() so that we can translate
386 * the pointers.
387 */
388 int
389 freebsd32_exec_copyin_args(struct image_args *args, const char *fname,
390 enum uio_seg segflg, uint32_t *argv, uint32_t *envv)
391 {
392 char *argp, *envp;
393 uint32_t *p32, arg;
394 int error;
395
396 bzero(args, sizeof(*args));
397 if (argv == NULL)
398 return (EFAULT);
399
400 /*
401 * Allocate demand-paged memory for the file name, argument, and
402 * environment strings.
403 */
404 error = exec_alloc_args(args);
405 if (error != 0)
406 return (error);
407
408 /*
409 * Copy the file name.
410 */
411 error = exec_args_add_fname(args, fname, segflg);
412 if (error != 0)
413 goto err_exit;
414
415 /*
416 * extract arguments first
417 */
418 p32 = argv;
419 for (;;) {
420 error = copyin(p32++, &arg, sizeof(arg));
421 if (error)
422 goto err_exit;
423 if (arg == 0)
424 break;
425 argp = PTRIN(arg);
426 error = exec_args_add_arg(args, argp, UIO_USERSPACE);
427 if (error != 0)
428 goto err_exit;
429 }
430
431 /*
432 * extract environment strings
433 */
434 if (envv) {
435 p32 = envv;
436 for (;;) {
437 error = copyin(p32++, &arg, sizeof(arg));
438 if (error)
439 goto err_exit;
440 if (arg == 0)
441 break;
442 envp = PTRIN(arg);
443 error = exec_args_add_env(args, envp, UIO_USERSPACE);
444 if (error != 0)
445 goto err_exit;
446 }
447 }
448
449 return (0);
450
451 err_exit:
452 exec_free_args(args);
453 return (error);
454 }
455
456 int
457 freebsd32_execve(struct thread *td, struct freebsd32_execve_args *uap)
458 {
459 struct image_args eargs;
460 struct vmspace *oldvmspace;
461 int error;
462
463 error = pre_execve(td, &oldvmspace);
464 if (error != 0)
465 return (error);
466 error = freebsd32_exec_copyin_args(&eargs, uap->fname, UIO_USERSPACE,
467 uap->argv, uap->envv);
468 if (error == 0)
469 error = kern_execve(td, &eargs, NULL, oldvmspace);
470 post_execve(td, error, oldvmspace);
471 AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
472 return (error);
473 }
474
475 int
476 freebsd32_fexecve(struct thread *td, struct freebsd32_fexecve_args *uap)
477 {
478 struct image_args eargs;
479 struct vmspace *oldvmspace;
480 int error;
481
482 error = pre_execve(td, &oldvmspace);
483 if (error != 0)
484 return (error);
485 error = freebsd32_exec_copyin_args(&eargs, NULL, UIO_SYSSPACE,
486 uap->argv, uap->envv);
487 if (error == 0) {
488 eargs.fd = uap->fd;
489 error = kern_execve(td, &eargs, NULL, oldvmspace);
490 }
491 post_execve(td, error, oldvmspace);
492 AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
493 return (error);
494 }
495
496 int
497 freebsd32_mknodat(struct thread *td, struct freebsd32_mknodat_args *uap)
498 {
499
500 return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE,
501 uap->mode, PAIR32TO64(dev_t, uap->dev)));
502 }
503
504 int
505 freebsd32_mprotect(struct thread *td, struct freebsd32_mprotect_args *uap)
506 {
507 int prot;
508
509 prot = uap->prot;
510 #if defined(__amd64__)
511 if (i386_read_exec && (prot & PROT_READ) != 0)
512 prot |= PROT_EXEC;
513 #endif
514 return (kern_mprotect(td, (uintptr_t)PTRIN(uap->addr), uap->len,
515 prot));
516 }
517
518 int
519 freebsd32_mmap(struct thread *td, struct freebsd32_mmap_args *uap)
520 {
521 int prot;
522
523 prot = uap->prot;
524 #if defined(__amd64__)
525 if (i386_read_exec && (prot & PROT_READ))
526 prot |= PROT_EXEC;
527 #endif
528
529 return (kern_mmap(td, &(struct mmap_req){
530 .mr_hint = (uintptr_t)uap->addr,
531 .mr_len = uap->len,
532 .mr_prot = prot,
533 .mr_flags = uap->flags,
534 .mr_fd = uap->fd,
535 .mr_pos = PAIR32TO64(off_t, uap->pos),
536 }));
537 }
538
539 #ifdef COMPAT_FREEBSD6
540 int
541 freebsd6_freebsd32_mmap(struct thread *td,
542 struct freebsd6_freebsd32_mmap_args *uap)
543 {
544 int prot;
545
546 prot = uap->prot;
547 #if defined(__amd64__)
548 if (i386_read_exec && (prot & PROT_READ))
549 prot |= PROT_EXEC;
550 #endif
551
552 return (kern_mmap(td, &(struct mmap_req){
553 .mr_hint = (uintptr_t)uap->addr,
554 .mr_len = uap->len,
555 .mr_prot = prot,
556 .mr_flags = uap->flags,
557 .mr_fd = uap->fd,
558 .mr_pos = PAIR32TO64(off_t, uap->pos),
559 }));
560 }
561 #endif
562
563 #ifdef COMPAT_43
564 int
565 ofreebsd32_mmap(struct thread *td, struct ofreebsd32_mmap_args *uap)
566 {
567 return (kern_ommap(td, (uintptr_t)uap->addr, uap->len, uap->prot,
568 uap->flags, uap->fd, uap->pos));
569 }
570 #endif
571
572 int
573 freebsd32_setitimer(struct thread *td, struct freebsd32_setitimer_args *uap)
574 {
575 struct itimerval itv, oitv, *itvp;
576 struct itimerval32 i32;
577 int error;
578
579 if (uap->itv != NULL) {
580 error = copyin(uap->itv, &i32, sizeof(i32));
581 if (error)
582 return (error);
583 TV_CP(i32, itv, it_interval);
584 TV_CP(i32, itv, it_value);
585 itvp = &itv;
586 } else
587 itvp = NULL;
588 error = kern_setitimer(td, uap->which, itvp, &oitv);
589 if (error || uap->oitv == NULL)
590 return (error);
591 TV_CP(oitv, i32, it_interval);
592 TV_CP(oitv, i32, it_value);
593 return (copyout(&i32, uap->oitv, sizeof(i32)));
594 }
595
596 int
597 freebsd32_getitimer(struct thread *td, struct freebsd32_getitimer_args *uap)
598 {
599 struct itimerval itv;
600 struct itimerval32 i32;
601 int error;
602
603 error = kern_getitimer(td, uap->which, &itv);
604 if (error || uap->itv == NULL)
605 return (error);
606 TV_CP(itv, i32, it_interval);
607 TV_CP(itv, i32, it_value);
608 return (copyout(&i32, uap->itv, sizeof(i32)));
609 }
610
611 int
612 freebsd32_select(struct thread *td, struct freebsd32_select_args *uap)
613 {
614 struct timeval32 tv32;
615 struct timeval tv, *tvp;
616 int error;
617
618 if (uap->tv != NULL) {
619 error = copyin(uap->tv, &tv32, sizeof(tv32));
620 if (error)
621 return (error);
622 CP(tv32, tv, tv_sec);
623 CP(tv32, tv, tv_usec);
624 tvp = &tv;
625 } else
626 tvp = NULL;
627 /*
628 * XXX Do pointers need PTRIN()?
629 */
630 return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
631 sizeof(int32_t) * 8));
632 }
633
634 int
635 freebsd32_pselect(struct thread *td, struct freebsd32_pselect_args *uap)
636 {
637 struct timespec32 ts32;
638 struct timespec ts;
639 struct timeval tv, *tvp;
640 sigset_t set, *uset;
641 int error;
642
643 if (uap->ts != NULL) {
644 error = copyin(uap->ts, &ts32, sizeof(ts32));
645 if (error != 0)
646 return (error);
647 CP(ts32, ts, tv_sec);
648 CP(ts32, ts, tv_nsec);
649 TIMESPEC_TO_TIMEVAL(&tv, &ts);
650 tvp = &tv;
651 } else
652 tvp = NULL;
653 if (uap->sm != NULL) {
654 error = copyin(uap->sm, &set, sizeof(set));
655 if (error != 0)
656 return (error);
657 uset = &set;
658 } else
659 uset = NULL;
660 /*
661 * XXX Do pointers need PTRIN()?
662 */
663 error = kern_pselect(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
664 uset, sizeof(int32_t) * 8);
665 return (error);
666 }
667
668 /*
669 * Copy 'count' items into the destination list pointed to by uap->eventlist.
670 */
671 static int
672 freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count)
673 {
674 struct freebsd32_kevent_args *uap;
675 struct kevent32 ks32[KQ_NEVENTS];
676 uint64_t e;
677 int i, j, error;
678
679 KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
680 uap = (struct freebsd32_kevent_args *)arg;
681
682 for (i = 0; i < count; i++) {
683 CP(kevp[i], ks32[i], ident);
684 CP(kevp[i], ks32[i], filter);
685 CP(kevp[i], ks32[i], flags);
686 CP(kevp[i], ks32[i], fflags);
687 #if BYTE_ORDER == LITTLE_ENDIAN
688 ks32[i].data1 = kevp[i].data;
689 ks32[i].data2 = kevp[i].data >> 32;
690 #else
691 ks32[i].data1 = kevp[i].data >> 32;
692 ks32[i].data2 = kevp[i].data;
693 #endif
694 PTROUT_CP(kevp[i], ks32[i], udata);
695 for (j = 0; j < nitems(kevp->ext); j++) {
696 e = kevp[i].ext[j];
697 #if BYTE_ORDER == LITTLE_ENDIAN
698 ks32[i].ext64[2 * j] = e;
699 ks32[i].ext64[2 * j + 1] = e >> 32;
700 #else
701 ks32[i].ext64[2 * j] = e >> 32;
702 ks32[i].ext64[2 * j + 1] = e;
703 #endif
704 }
705 }
706 error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
707 if (error == 0)
708 uap->eventlist += count;
709 return (error);
710 }
711
712 /*
713 * Copy 'count' items from the list pointed to by uap->changelist.
714 */
715 static int
716 freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count)
717 {
718 struct freebsd32_kevent_args *uap;
719 struct kevent32 ks32[KQ_NEVENTS];
720 uint64_t e;
721 int i, j, error;
722
723 KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
724 uap = (struct freebsd32_kevent_args *)arg;
725
726 error = copyin(uap->changelist, ks32, count * sizeof *ks32);
727 if (error)
728 goto done;
729 uap->changelist += count;
730
731 for (i = 0; i < count; i++) {
732 CP(ks32[i], kevp[i], ident);
733 CP(ks32[i], kevp[i], filter);
734 CP(ks32[i], kevp[i], flags);
735 CP(ks32[i], kevp[i], fflags);
736 kevp[i].data = PAIR32TO64(uint64_t, ks32[i].data);
737 PTRIN_CP(ks32[i], kevp[i], udata);
738 for (j = 0; j < nitems(kevp->ext); j++) {
739 #if BYTE_ORDER == LITTLE_ENDIAN
740 e = ks32[i].ext64[2 * j + 1];
741 e <<= 32;
742 e += ks32[i].ext64[2 * j];
743 #else
744 e = ks32[i].ext64[2 * j];
745 e <<= 32;
746 e += ks32[i].ext64[2 * j + 1];
747 #endif
748 kevp[i].ext[j] = e;
749 }
750 }
751 done:
752 return (error);
753 }
754
755 int
756 freebsd32_kevent(struct thread *td, struct freebsd32_kevent_args *uap)
757 {
758 struct timespec32 ts32;
759 struct timespec ts, *tsp;
760 struct kevent_copyops k_ops = {
761 .arg = uap,
762 .k_copyout = freebsd32_kevent_copyout,
763 .k_copyin = freebsd32_kevent_copyin,
764 };
765 #ifdef KTRACE
766 struct kevent32 *eventlist = uap->eventlist;
767 #endif
768 int error;
769
770 if (uap->timeout) {
771 error = copyin(uap->timeout, &ts32, sizeof(ts32));
772 if (error)
773 return (error);
774 CP(ts32, ts, tv_sec);
775 CP(ts32, ts, tv_nsec);
776 tsp = &ts;
777 } else
778 tsp = NULL;
779 #ifdef KTRACE
780 if (KTRPOINT(td, KTR_STRUCT_ARRAY))
781 ktrstructarray("kevent32", UIO_USERSPACE, uap->changelist,
782 uap->nchanges, sizeof(struct kevent32));
783 #endif
784 error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
785 &k_ops, tsp);
786 #ifdef KTRACE
787 if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY))
788 ktrstructarray("kevent32", UIO_USERSPACE, eventlist,
789 td->td_retval[0], sizeof(struct kevent32));
790 #endif
791 return (error);
792 }
793
794 #ifdef COMPAT_FREEBSD11
795 static int
796 freebsd32_kevent11_copyout(void *arg, struct kevent *kevp, int count)
797 {
798 struct freebsd11_freebsd32_kevent_args *uap;
799 struct freebsd11_kevent32 ks32[KQ_NEVENTS];
800 int i, error;
801
802 KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
803 uap = (struct freebsd11_freebsd32_kevent_args *)arg;
804
805 for (i = 0; i < count; i++) {
806 CP(kevp[i], ks32[i], ident);
807 CP(kevp[i], ks32[i], filter);
808 CP(kevp[i], ks32[i], flags);
809 CP(kevp[i], ks32[i], fflags);
810 CP(kevp[i], ks32[i], data);
811 PTROUT_CP(kevp[i], ks32[i], udata);
812 }
813 error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
814 if (error == 0)
815 uap->eventlist += count;
816 return (error);
817 }
818
819 /*
820 * Copy 'count' items from the list pointed to by uap->changelist.
821 */
822 static int
823 freebsd32_kevent11_copyin(void *arg, struct kevent *kevp, int count)
824 {
825 struct freebsd11_freebsd32_kevent_args *uap;
826 struct freebsd11_kevent32 ks32[KQ_NEVENTS];
827 int i, j, error;
828
829 KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
830 uap = (struct freebsd11_freebsd32_kevent_args *)arg;
831
832 error = copyin(uap->changelist, ks32, count * sizeof *ks32);
833 if (error)
834 goto done;
835 uap->changelist += count;
836
837 for (i = 0; i < count; i++) {
838 CP(ks32[i], kevp[i], ident);
839 CP(ks32[i], kevp[i], filter);
840 CP(ks32[i], kevp[i], flags);
841 CP(ks32[i], kevp[i], fflags);
842 CP(ks32[i], kevp[i], data);
843 PTRIN_CP(ks32[i], kevp[i], udata);
844 for (j = 0; j < nitems(kevp->ext); j++)
845 kevp[i].ext[j] = 0;
846 }
847 done:
848 return (error);
849 }
850
851 int
852 freebsd11_freebsd32_kevent(struct thread *td,
853 struct freebsd11_freebsd32_kevent_args *uap)
854 {
855 struct timespec32 ts32;
856 struct timespec ts, *tsp;
857 struct kevent_copyops k_ops = {
858 .arg = uap,
859 .k_copyout = freebsd32_kevent11_copyout,
860 .k_copyin = freebsd32_kevent11_copyin,
861 };
862 #ifdef KTRACE
863 struct freebsd11_kevent32 *eventlist = uap->eventlist;
864 #endif
865 int error;
866
867 if (uap->timeout) {
868 error = copyin(uap->timeout, &ts32, sizeof(ts32));
869 if (error)
870 return (error);
871 CP(ts32, ts, tv_sec);
872 CP(ts32, ts, tv_nsec);
873 tsp = &ts;
874 } else
875 tsp = NULL;
876 #ifdef KTRACE
877 if (KTRPOINT(td, KTR_STRUCT_ARRAY))
878 ktrstructarray("freebsd11_kevent32", UIO_USERSPACE,
879 uap->changelist, uap->nchanges,
880 sizeof(struct freebsd11_kevent32));
881 #endif
882 error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
883 &k_ops, tsp);
884 #ifdef KTRACE
885 if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY))
886 ktrstructarray("freebsd11_kevent32", UIO_USERSPACE,
887 eventlist, td->td_retval[0],
888 sizeof(struct freebsd11_kevent32));
889 #endif
890 return (error);
891 }
892 #endif
893
894 int
895 freebsd32_gettimeofday(struct thread *td,
896 struct freebsd32_gettimeofday_args *uap)
897 {
898 struct timeval atv;
899 struct timeval32 atv32;
900 struct timezone rtz;
901 int error = 0;
902
903 if (uap->tp) {
904 microtime(&atv);
905 CP(atv, atv32, tv_sec);
906 CP(atv, atv32, tv_usec);
907 error = copyout(&atv32, uap->tp, sizeof (atv32));
908 }
909 if (error == 0 && uap->tzp != NULL) {
910 rtz.tz_minuteswest = 0;
911 rtz.tz_dsttime = 0;
912 error = copyout(&rtz, uap->tzp, sizeof (rtz));
913 }
914 return (error);
915 }
916
917 int
918 freebsd32_getrusage(struct thread *td, struct freebsd32_getrusage_args *uap)
919 {
920 struct rusage32 s32;
921 struct rusage s;
922 int error;
923
924 error = kern_getrusage(td, uap->who, &s);
925 if (error == 0) {
926 freebsd32_rusage_out(&s, &s32);
927 error = copyout(&s32, uap->rusage, sizeof(s32));
928 }
929 return (error);
930 }
931
932 static void
933 ptrace_lwpinfo_to32(const struct ptrace_lwpinfo *pl,
934 struct ptrace_lwpinfo32 *pl32)
935 {
936
937 bzero(pl32, sizeof(*pl32));
938 pl32->pl_lwpid = pl->pl_lwpid;
939 pl32->pl_event = pl->pl_event;
940 pl32->pl_flags = pl->pl_flags;
941 pl32->pl_sigmask = pl->pl_sigmask;
942 pl32->pl_siglist = pl->pl_siglist;
943 siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo);
944 strcpy(pl32->pl_tdname, pl->pl_tdname);
945 pl32->pl_child_pid = pl->pl_child_pid;
946 pl32->pl_syscall_code = pl->pl_syscall_code;
947 pl32->pl_syscall_narg = pl->pl_syscall_narg;
948 }
949
950 static void
951 ptrace_sc_ret_to32(const struct ptrace_sc_ret *psr,
952 struct ptrace_sc_ret32 *psr32)
953 {
954
955 bzero(psr32, sizeof(*psr32));
956 psr32->sr_retval[0] = psr->sr_retval[0];
957 psr32->sr_retval[1] = psr->sr_retval[1];
958 psr32->sr_error = psr->sr_error;
959 }
960
961 int
962 freebsd32_ptrace(struct thread *td, struct freebsd32_ptrace_args *uap)
963 {
964 union {
965 struct ptrace_io_desc piod;
966 struct ptrace_lwpinfo pl;
967 struct ptrace_vm_entry pve;
968 struct ptrace_coredump pc;
969 struct ptrace_sc_remote sr;
970 struct dbreg32 dbreg;
971 struct fpreg32 fpreg;
972 struct reg32 reg;
973 struct iovec vec;
974 register_t args[nitems(td->td_sa.args)];
975 struct ptrace_sc_ret psr;
976 int ptevents;
977 } r;
978 union {
979 struct ptrace_io_desc32 piod;
980 struct ptrace_lwpinfo32 pl;
981 struct ptrace_vm_entry32 pve;
982 struct ptrace_coredump32 pc;
983 struct ptrace_sc_remote32 sr;
984 uint32_t args[nitems(td->td_sa.args)];
985 struct ptrace_sc_ret32 psr;
986 struct iovec32 vec;
987 } r32;
988 syscallarg_t pscr_args[nitems(td->td_sa.args)];
989 u_int pscr_args32[nitems(td->td_sa.args)];
990 void *addr;
991 int data, error, i;
992
993 if (!allow_ptrace)
994 return (ENOSYS);
995 error = 0;
996
997 AUDIT_ARG_PID(uap->pid);
998 AUDIT_ARG_CMD(uap->req);
999 AUDIT_ARG_VALUE(uap->data);
1000 addr = &r;
1001 data = uap->data;
1002 switch (uap->req) {
1003 case PT_GET_EVENT_MASK:
1004 case PT_GET_SC_ARGS:
1005 case PT_GET_SC_RET:
1006 break;
1007 case PT_LWPINFO:
1008 if (uap->data > sizeof(r32.pl))
1009 return (EINVAL);
1010
1011 /*
1012 * Pass size of native structure in 'data'. Truncate
1013 * if necessary to avoid siginfo.
1014 */
1015 data = sizeof(r.pl);
1016 if (uap->data < offsetof(struct ptrace_lwpinfo32, pl_siginfo) +
1017 sizeof(struct siginfo32))
1018 data = offsetof(struct ptrace_lwpinfo, pl_siginfo);
1019 break;
1020 case PT_GETREGS:
1021 bzero(&r.reg, sizeof(r.reg));
1022 break;
1023 case PT_GETFPREGS:
1024 bzero(&r.fpreg, sizeof(r.fpreg));
1025 break;
1026 case PT_GETDBREGS:
1027 bzero(&r.dbreg, sizeof(r.dbreg));
1028 break;
1029 case PT_SETREGS:
1030 error = copyin(uap->addr, &r.reg, sizeof(r.reg));
1031 break;
1032 case PT_SETFPREGS:
1033 error = copyin(uap->addr, &r.fpreg, sizeof(r.fpreg));
1034 break;
1035 case PT_SETDBREGS:
1036 error = copyin(uap->addr, &r.dbreg, sizeof(r.dbreg));
1037 break;
1038 case PT_GETREGSET:
1039 case PT_SETREGSET:
1040 error = copyin(uap->addr, &r32.vec, sizeof(r32.vec));
1041 if (error != 0)
1042 break;
1043
1044 r.vec.iov_len = r32.vec.iov_len;
1045 r.vec.iov_base = PTRIN(r32.vec.iov_base);
1046 break;
1047 case PT_SET_EVENT_MASK:
1048 if (uap->data != sizeof(r.ptevents))
1049 error = EINVAL;
1050 else
1051 error = copyin(uap->addr, &r.ptevents, uap->data);
1052 break;
1053 case PT_IO:
1054 error = copyin(uap->addr, &r32.piod, sizeof(r32.piod));
1055 if (error)
1056 break;
1057 CP(r32.piod, r.piod, piod_op);
1058 PTRIN_CP(r32.piod, r.piod, piod_offs);
1059 PTRIN_CP(r32.piod, r.piod, piod_addr);
1060 CP(r32.piod, r.piod, piod_len);
1061 break;
1062 case PT_VM_ENTRY:
1063 error = copyin(uap->addr, &r32.pve, sizeof(r32.pve));
1064 if (error)
1065 break;
1066
1067 CP(r32.pve, r.pve, pve_entry);
1068 CP(r32.pve, r.pve, pve_timestamp);
1069 CP(r32.pve, r.pve, pve_start);
1070 CP(r32.pve, r.pve, pve_end);
1071 CP(r32.pve, r.pve, pve_offset);
1072 CP(r32.pve, r.pve, pve_prot);
1073 CP(r32.pve, r.pve, pve_pathlen);
1074 CP(r32.pve, r.pve, pve_fileid);
1075 CP(r32.pve, r.pve, pve_fsid);
1076 PTRIN_CP(r32.pve, r.pve, pve_path);
1077 break;
1078 case PT_COREDUMP:
1079 if (uap->data != sizeof(r32.pc))
1080 error = EINVAL;
1081 else
1082 error = copyin(uap->addr, &r32.pc, uap->data);
1083 CP(r32.pc, r.pc, pc_fd);
1084 CP(r32.pc, r.pc, pc_flags);
1085 r.pc.pc_limit = PAIR32TO64(off_t, r32.pc.pc_limit);
1086 data = sizeof(r.pc);
1087 break;
1088 case PT_SC_REMOTE:
1089 if (uap->data != sizeof(r32.sr)) {
1090 error = EINVAL;
1091 break;
1092 }
1093 error = copyin(uap->addr, &r32.sr, uap->data);
1094 if (error != 0)
1095 break;
1096 CP(r32.sr, r.sr, pscr_syscall);
1097 CP(r32.sr, r.sr, pscr_nargs);
1098 if (r.sr.pscr_nargs > nitems(td->td_sa.args)) {
1099 error = EINVAL;
1100 break;
1101 }
1102 error = copyin(PTRIN(r32.sr.pscr_args), pscr_args32,
1103 sizeof(u_int) * r32.sr.pscr_nargs);
1104 if (error != 0)
1105 break;
1106 for (i = 0; i < r32.sr.pscr_nargs; i++)
1107 pscr_args[i] = pscr_args32[i];
1108 r.sr.pscr_args = pscr_args;
1109 break;
1110 default:
1111 addr = uap->addr;
1112 break;
1113 }
1114 if (error)
1115 return (error);
1116
1117 error = kern_ptrace(td, uap->req, uap->pid, addr, data);
1118 if (error)
1119 return (error);
1120
1121 switch (uap->req) {
1122 case PT_VM_ENTRY:
1123 CP(r.pve, r32.pve, pve_entry);
1124 CP(r.pve, r32.pve, pve_timestamp);
1125 CP(r.pve, r32.pve, pve_start);
1126 CP(r.pve, r32.pve, pve_end);
1127 CP(r.pve, r32.pve, pve_offset);
1128 CP(r.pve, r32.pve, pve_prot);
1129 CP(r.pve, r32.pve, pve_pathlen);
1130 CP(r.pve, r32.pve, pve_fileid);
1131 CP(r.pve, r32.pve, pve_fsid);
1132 error = copyout(&r32.pve, uap->addr, sizeof(r32.pve));
1133 break;
1134 case PT_IO:
1135 CP(r.piod, r32.piod, piod_len);
1136 error = copyout(&r32.piod, uap->addr, sizeof(r32.piod));
1137 break;
1138 case PT_GETREGS:
1139 error = copyout(&r.reg, uap->addr, sizeof(r.reg));
1140 break;
1141 case PT_GETFPREGS:
1142 error = copyout(&r.fpreg, uap->addr, sizeof(r.fpreg));
1143 break;
1144 case PT_GETDBREGS:
1145 error = copyout(&r.dbreg, uap->addr, sizeof(r.dbreg));
1146 break;
1147 case PT_GETREGSET:
1148 r32.vec.iov_len = r.vec.iov_len;
1149 error = copyout(&r32.vec, uap->addr, sizeof(r32.vec));
1150 break;
1151 case PT_GET_EVENT_MASK:
1152 /* NB: The size in uap->data is validated in kern_ptrace(). */
1153 error = copyout(&r.ptevents, uap->addr, uap->data);
1154 break;
1155 case PT_LWPINFO:
1156 ptrace_lwpinfo_to32(&r.pl, &r32.pl);
1157 error = copyout(&r32.pl, uap->addr, uap->data);
1158 break;
1159 case PT_GET_SC_ARGS:
1160 for (i = 0; i < nitems(r.args); i++)
1161 r32.args[i] = (uint32_t)r.args[i];
1162 error = copyout(r32.args, uap->addr, MIN(uap->data,
1163 sizeof(r32.args)));
1164 break;
1165 case PT_GET_SC_RET:
1166 ptrace_sc_ret_to32(&r.psr, &r32.psr);
1167 error = copyout(&r32.psr, uap->addr, MIN(uap->data,
1168 sizeof(r32.psr)));
1169 break;
1170 case PT_SC_REMOTE:
1171 ptrace_sc_ret_to32(&r.sr.pscr_ret, &r32.sr.pscr_ret);
1172 error = copyout(&r32.sr.pscr_ret, uap->addr +
1173 offsetof(struct ptrace_sc_remote32, pscr_ret),
1174 sizeof(r32.psr));
1175 break;
1176 }
1177
1178 return (error);
1179 }
1180
1181 int
1182 freebsd32_copyinuio(struct iovec32 *iovp, u_int iovcnt, struct uio **uiop)
1183 {
1184 struct iovec32 iov32;
1185 struct iovec *iov;
1186 struct uio *uio;
1187 u_int iovlen;
1188 int error, i;
1189
1190 *uiop = NULL;
1191 if (iovcnt > UIO_MAXIOV)
1192 return (EINVAL);
1193 iovlen = iovcnt * sizeof(struct iovec);
1194 uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK);
1195 iov = (struct iovec *)(uio + 1);
1196 for (i = 0; i < iovcnt; i++) {
1197 error = copyin(&iovp[i], &iov32, sizeof(struct iovec32));
1198 if (error) {
1199 free(uio, M_IOV);
1200 return (error);
1201 }
1202 iov[i].iov_base = PTRIN(iov32.iov_base);
1203 iov[i].iov_len = iov32.iov_len;
1204 }
1205 uio->uio_iov = iov;
1206 uio->uio_iovcnt = iovcnt;
1207 uio->uio_segflg = UIO_USERSPACE;
1208 uio->uio_offset = -1;
1209 uio->uio_resid = 0;
1210 for (i = 0; i < iovcnt; i++) {
1211 if (iov->iov_len > INT_MAX - uio->uio_resid) {
1212 free(uio, M_IOV);
1213 return (EINVAL);
1214 }
1215 uio->uio_resid += iov->iov_len;
1216 iov++;
1217 }
1218 *uiop = uio;
1219 return (0);
1220 }
1221
1222 int
1223 freebsd32_readv(struct thread *td, struct freebsd32_readv_args *uap)
1224 {
1225 struct uio *auio;
1226 int error;
1227
1228 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1229 if (error)
1230 return (error);
1231 error = kern_readv(td, uap->fd, auio);
1232 free(auio, M_IOV);
1233 return (error);
1234 }
1235
1236 int
1237 freebsd32_writev(struct thread *td, struct freebsd32_writev_args *uap)
1238 {
1239 struct uio *auio;
1240 int error;
1241
1242 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1243 if (error)
1244 return (error);
1245 error = kern_writev(td, uap->fd, auio);
1246 free(auio, M_IOV);
1247 return (error);
1248 }
1249
1250 int
1251 freebsd32_preadv(struct thread *td, struct freebsd32_preadv_args *uap)
1252 {
1253 struct uio *auio;
1254 int error;
1255
1256 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1257 if (error)
1258 return (error);
1259 error = kern_preadv(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
1260 free(auio, M_IOV);
1261 return (error);
1262 }
1263
1264 int
1265 freebsd32_pwritev(struct thread *td, struct freebsd32_pwritev_args *uap)
1266 {
1267 struct uio *auio;
1268 int error;
1269
1270 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1271 if (error)
1272 return (error);
1273 error = kern_pwritev(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
1274 free(auio, M_IOV);
1275 return (error);
1276 }
1277
1278 int
1279 freebsd32_copyiniov(struct iovec32 *iovp32, u_int iovcnt, struct iovec **iovp,
1280 int error)
1281 {
1282 struct iovec32 iov32;
1283 struct iovec *iov;
1284 u_int iovlen;
1285 int i;
1286
1287 *iovp = NULL;
1288 if (iovcnt > UIO_MAXIOV)
1289 return (error);
1290 iovlen = iovcnt * sizeof(struct iovec);
1291 iov = malloc(iovlen, M_IOV, M_WAITOK);
1292 for (i = 0; i < iovcnt; i++) {
1293 error = copyin(&iovp32[i], &iov32, sizeof(struct iovec32));
1294 if (error) {
1295 free(iov, M_IOV);
1296 return (error);
1297 }
1298 iov[i].iov_base = PTRIN(iov32.iov_base);
1299 iov[i].iov_len = iov32.iov_len;
1300 }
1301 *iovp = iov;
1302 return (0);
1303 }
1304
1305 static int
1306 freebsd32_copyinmsghdr(const struct msghdr32 *msg32, struct msghdr *msg)
1307 {
1308 struct msghdr32 m32;
1309 int error;
1310
1311 error = copyin(msg32, &m32, sizeof(m32));
1312 if (error)
1313 return (error);
1314 msg->msg_name = PTRIN(m32.msg_name);
1315 msg->msg_namelen = m32.msg_namelen;
1316 msg->msg_iov = PTRIN(m32.msg_iov);
1317 msg->msg_iovlen = m32.msg_iovlen;
1318 msg->msg_control = PTRIN(m32.msg_control);
1319 msg->msg_controllen = m32.msg_controllen;
1320 msg->msg_flags = m32.msg_flags;
1321 return (0);
1322 }
1323
1324 static int
1325 freebsd32_copyoutmsghdr(struct msghdr *msg, struct msghdr32 *msg32)
1326 {
1327 struct msghdr32 m32;
1328 int error;
1329
1330 m32.msg_name = PTROUT(msg->msg_name);
1331 m32.msg_namelen = msg->msg_namelen;
1332 m32.msg_iov = PTROUT(msg->msg_iov);
1333 m32.msg_iovlen = msg->msg_iovlen;
1334 m32.msg_control = PTROUT(msg->msg_control);
1335 m32.msg_controllen = msg->msg_controllen;
1336 m32.msg_flags = msg->msg_flags;
1337 error = copyout(&m32, msg32, sizeof(m32));
1338 return (error);
1339 }
1340
1341 #define FREEBSD32_ALIGNBYTES (sizeof(int) - 1)
1342 #define FREEBSD32_ALIGN(p) \
1343 (((u_long)(p) + FREEBSD32_ALIGNBYTES) & ~FREEBSD32_ALIGNBYTES)
1344 #define FREEBSD32_CMSG_SPACE(l) \
1345 (FREEBSD32_ALIGN(sizeof(struct cmsghdr)) + FREEBSD32_ALIGN(l))
1346
1347 #define FREEBSD32_CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + \
1348 FREEBSD32_ALIGN(sizeof(struct cmsghdr)))
1349
1350 static size_t
1351 freebsd32_cmsg_convert(const struct cmsghdr *cm, void *data, socklen_t datalen)
1352 {
1353 size_t copylen;
1354 union {
1355 struct timespec32 ts;
1356 struct timeval32 tv;
1357 struct bintime32 bt;
1358 } tmp32;
1359
1360 union {
1361 struct timespec ts;
1362 struct timeval tv;
1363 struct bintime bt;
1364 } *in;
1365
1366 in = data;
1367 copylen = 0;
1368 switch (cm->cmsg_level) {
1369 case SOL_SOCKET:
1370 switch (cm->cmsg_type) {
1371 case SCM_TIMESTAMP:
1372 TV_CP(*in, tmp32, tv);
1373 copylen = sizeof(tmp32.tv);
1374 break;
1375
1376 case SCM_BINTIME:
1377 BT_CP(*in, tmp32, bt);
1378 copylen = sizeof(tmp32.bt);
1379 break;
1380
1381 case SCM_REALTIME:
1382 case SCM_MONOTONIC:
1383 TS_CP(*in, tmp32, ts);
1384 copylen = sizeof(tmp32.ts);
1385 break;
1386
1387 default:
1388 break;
1389 }
1390
1391 default:
1392 break;
1393 }
1394
1395 if (copylen == 0)
1396 return (datalen);
1397
1398 KASSERT((datalen >= copylen), ("corrupted cmsghdr"));
1399
1400 bcopy(&tmp32, data, copylen);
1401 return (copylen);
1402 }
1403
1404 static int
1405 freebsd32_copy_msg_out(struct msghdr *msg, struct mbuf *control)
1406 {
1407 struct cmsghdr *cm;
1408 void *data;
1409 socklen_t clen, datalen, datalen_out, oldclen;
1410 int error;
1411 caddr_t ctlbuf;
1412 int len, copylen;
1413 struct mbuf *m;
1414 error = 0;
1415
1416 len = msg->msg_controllen;
1417 msg->msg_controllen = 0;
1418
1419 ctlbuf = msg->msg_control;
1420 for (m = control; m != NULL && len > 0; m = m->m_next) {
1421 cm = mtod(m, struct cmsghdr *);
1422 clen = m->m_len;
1423 while (cm != NULL) {
1424 if (sizeof(struct cmsghdr) > clen ||
1425 cm->cmsg_len > clen) {
1426 error = EINVAL;
1427 break;
1428 }
1429
1430 data = CMSG_DATA(cm);
1431 datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
1432 datalen_out = freebsd32_cmsg_convert(cm, data, datalen);
1433
1434 /*
1435 * Copy out the message header. Preserve the native
1436 * message size in case we need to inspect the message
1437 * contents later.
1438 */
1439 copylen = sizeof(struct cmsghdr);
1440 if (len < copylen) {
1441 msg->msg_flags |= MSG_CTRUNC;
1442 m_dispose_extcontrolm(m);
1443 goto exit;
1444 }
1445 oldclen = cm->cmsg_len;
1446 cm->cmsg_len = FREEBSD32_ALIGN(sizeof(struct cmsghdr)) +
1447 datalen_out;
1448 error = copyout(cm, ctlbuf, copylen);
1449 cm->cmsg_len = oldclen;
1450 if (error != 0)
1451 goto exit;
1452
1453 ctlbuf += FREEBSD32_ALIGN(copylen);
1454 len -= FREEBSD32_ALIGN(copylen);
1455
1456 copylen = datalen_out;
1457 if (len < copylen) {
1458 msg->msg_flags |= MSG_CTRUNC;
1459 m_dispose_extcontrolm(m);
1460 break;
1461 }
1462
1463 /* Copy out the message data. */
1464 error = copyout(data, ctlbuf, copylen);
1465 if (error)
1466 goto exit;
1467
1468 ctlbuf += FREEBSD32_ALIGN(copylen);
1469 len -= FREEBSD32_ALIGN(copylen);
1470
1471 if (CMSG_SPACE(datalen) < clen) {
1472 clen -= CMSG_SPACE(datalen);
1473 cm = (struct cmsghdr *)
1474 ((caddr_t)cm + CMSG_SPACE(datalen));
1475 } else {
1476 clen = 0;
1477 cm = NULL;
1478 }
1479
1480 msg->msg_controllen +=
1481 FREEBSD32_CMSG_SPACE(datalen_out);
1482 }
1483 }
1484 if (len == 0 && m != NULL) {
1485 msg->msg_flags |= MSG_CTRUNC;
1486 m_dispose_extcontrolm(m);
1487 }
1488
1489 exit:
1490 return (error);
1491 }
1492
1493 int
1494 freebsd32_recvmsg(struct thread *td, struct freebsd32_recvmsg_args *uap)
1495 {
1496 struct msghdr msg;
1497 struct iovec *uiov, *iov;
1498 struct mbuf *control = NULL;
1499 struct mbuf **controlp;
1500 int error;
1501
1502 error = freebsd32_copyinmsghdr(uap->msg, &msg);
1503 if (error)
1504 return (error);
1505 error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov,
1506 EMSGSIZE);
1507 if (error)
1508 return (error);
1509 msg.msg_flags = uap->flags;
1510 uiov = msg.msg_iov;
1511 msg.msg_iov = iov;
1512
1513 controlp = (msg.msg_control != NULL) ? &control : NULL;
1514 error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, controlp);
1515 if (error == 0) {
1516 msg.msg_iov = uiov;
1517
1518 if (control != NULL)
1519 error = freebsd32_copy_msg_out(&msg, control);
1520 else
1521 msg.msg_controllen = 0;
1522
1523 if (error == 0)
1524 error = freebsd32_copyoutmsghdr(&msg, uap->msg);
1525 }
1526 free(iov, M_IOV);
1527
1528 if (control != NULL) {
1529 if (error != 0)
1530 m_dispose_extcontrolm(control);
1531 m_freem(control);
1532 }
1533
1534 return (error);
1535 }
1536
1537 #ifdef COMPAT_43
1538 int
1539 ofreebsd32_recvmsg(struct thread *td, struct ofreebsd32_recvmsg_args *uap)
1540 {
1541 return (ENOSYS);
1542 }
1543 #endif
1544
1545 /*
1546 * Copy-in the array of control messages constructed using alignment
1547 * and padding suitable for a 32-bit environment and construct an
1548 * mbuf using alignment and padding suitable for a 64-bit kernel.
1549 * The alignment and padding are defined indirectly by CMSG_DATA(),
1550 * CMSG_SPACE() and CMSG_LEN().
1551 */
1552 static int
1553 freebsd32_copyin_control(struct mbuf **mp, caddr_t buf, u_int buflen)
1554 {
1555 struct cmsghdr *cm;
1556 struct mbuf *m;
1557 void *in, *in1, *md;
1558 u_int msglen, outlen;
1559 int error;
1560
1561 /* Enforce the size limit of the native implementation. */
1562 if (buflen > MCLBYTES)
1563 return (EINVAL);
1564
1565 in = malloc(buflen, M_TEMP, M_WAITOK);
1566 error = copyin(buf, in, buflen);
1567 if (error != 0)
1568 goto out;
1569
1570 /*
1571 * Make a pass over the input buffer to determine the amount of space
1572 * required for 64 bit-aligned copies of the control messages.
1573 */
1574 in1 = in;
1575 outlen = 0;
1576 while (buflen > 0) {
1577 if (buflen < sizeof(*cm)) {
1578 error = EINVAL;
1579 break;
1580 }
1581 cm = (struct cmsghdr *)in1;
1582 if (cm->cmsg_len < FREEBSD32_ALIGN(sizeof(*cm)) ||
1583 cm->cmsg_len > buflen) {
1584 error = EINVAL;
1585 break;
1586 }
1587 msglen = FREEBSD32_ALIGN(cm->cmsg_len);
1588 if (msglen < cm->cmsg_len) {
1589 error = EINVAL;
1590 break;
1591 }
1592 /* The native ABI permits the final padding to be omitted. */
1593 if (msglen > buflen)
1594 msglen = buflen;
1595 buflen -= msglen;
1596
1597 in1 = (char *)in1 + msglen;
1598 outlen += CMSG_ALIGN(sizeof(*cm)) +
1599 CMSG_ALIGN(msglen - FREEBSD32_ALIGN(sizeof(*cm)));
1600 }
1601 if (error != 0)
1602 goto out;
1603
1604 /*
1605 * Allocate up to MJUMPAGESIZE space for the re-aligned and
1606 * re-padded control messages. This allows a full MCLBYTES of
1607 * 32-bit sized and aligned messages to fit and avoids an ABI
1608 * mismatch with the native implementation.
1609 */
1610 m = m_get2(outlen, M_WAITOK, MT_CONTROL, 0);
1611 if (m == NULL) {
1612 error = EINVAL;
1613 goto out;
1614 }
1615 m->m_len = outlen;
1616 md = mtod(m, void *);
1617
1618 /*
1619 * Make a second pass over input messages, copying them into the output
1620 * buffer.
1621 */
1622 in1 = in;
1623 while (outlen > 0) {
1624 /* Copy the message header and align the length field. */
1625 cm = md;
1626 memcpy(cm, in1, sizeof(*cm));
1627 msglen = cm->cmsg_len - FREEBSD32_ALIGN(sizeof(*cm));
1628 cm->cmsg_len = CMSG_ALIGN(sizeof(*cm)) + msglen;
1629
1630 /* Copy the message body. */
1631 in1 = (char *)in1 + FREEBSD32_ALIGN(sizeof(*cm));
1632 md = (char *)md + CMSG_ALIGN(sizeof(*cm));
1633 memcpy(md, in1, msglen);
1634 in1 = (char *)in1 + FREEBSD32_ALIGN(msglen);
1635 md = (char *)md + CMSG_ALIGN(msglen);
1636 KASSERT(outlen >= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen),
1637 ("outlen %u underflow, msglen %u", outlen, msglen));
1638 outlen -= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen);
1639 }
1640
1641 *mp = m;
1642 out:
1643 free(in, M_TEMP);
1644 return (error);
1645 }
1646
1647 int
1648 freebsd32_sendmsg(struct thread *td, struct freebsd32_sendmsg_args *uap)
1649 {
1650 struct msghdr msg;
1651 struct iovec *iov;
1652 struct mbuf *control = NULL;
1653 struct sockaddr *to = NULL;
1654 int error;
1655
1656 error = freebsd32_copyinmsghdr(uap->msg, &msg);
1657 if (error)
1658 return (error);
1659 error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov,
1660 EMSGSIZE);
1661 if (error)
1662 return (error);
1663 msg.msg_iov = iov;
1664 if (msg.msg_name != NULL) {
1665 error = getsockaddr(&to, msg.msg_name, msg.msg_namelen);
1666 if (error) {
1667 to = NULL;
1668 goto out;
1669 }
1670 msg.msg_name = to;
1671 }
1672
1673 if (msg.msg_control) {
1674 if (msg.msg_controllen < sizeof(struct cmsghdr)) {
1675 error = EINVAL;
1676 goto out;
1677 }
1678
1679 error = freebsd32_copyin_control(&control, msg.msg_control,
1680 msg.msg_controllen);
1681 if (error)
1682 goto out;
1683
1684 msg.msg_control = NULL;
1685 msg.msg_controllen = 0;
1686 }
1687
1688 error = kern_sendit(td, uap->s, &msg, uap->flags, control,
1689 UIO_USERSPACE);
1690
1691 out:
1692 free(iov, M_IOV);
1693 if (to)
1694 free(to, M_SONAME);
1695 return (error);
1696 }
1697
1698 #ifdef COMPAT_43
1699 int
1700 ofreebsd32_sendmsg(struct thread *td, struct ofreebsd32_sendmsg_args *uap)
1701 {
1702 return (ENOSYS);
1703 }
1704 #endif
1705
1706
1707 int
1708 freebsd32_settimeofday(struct thread *td,
1709 struct freebsd32_settimeofday_args *uap)
1710 {
1711 struct timeval32 tv32;
1712 struct timeval tv, *tvp;
1713 struct timezone tz, *tzp;
1714 int error;
1715
1716 if (uap->tv) {
1717 error = copyin(uap->tv, &tv32, sizeof(tv32));
1718 if (error)
1719 return (error);
1720 CP(tv32, tv, tv_sec);
1721 CP(tv32, tv, tv_usec);
1722 tvp = &tv;
1723 } else
1724 tvp = NULL;
1725 if (uap->tzp) {
1726 error = copyin(uap->tzp, &tz, sizeof(tz));
1727 if (error)
1728 return (error);
1729 tzp = &tz;
1730 } else
1731 tzp = NULL;
1732 return (kern_settimeofday(td, tvp, tzp));
1733 }
1734
1735 int
1736 freebsd32_utimes(struct thread *td, struct freebsd32_utimes_args *uap)
1737 {
1738 struct timeval32 s32[2];
1739 struct timeval s[2], *sp;
1740 int error;
1741
1742 if (uap->tptr != NULL) {
1743 error = copyin(uap->tptr, s32, sizeof(s32));
1744 if (error)
1745 return (error);
1746 CP(s32[0], s[0], tv_sec);
1747 CP(s32[0], s[0], tv_usec);
1748 CP(s32[1], s[1], tv_sec);
1749 CP(s32[1], s[1], tv_usec);
1750 sp = s;
1751 } else
1752 sp = NULL;
1753 return (kern_utimesat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
1754 sp, UIO_SYSSPACE));
1755 }
1756
1757 int
1758 freebsd32_lutimes(struct thread *td, struct freebsd32_lutimes_args *uap)
1759 {
1760 struct timeval32 s32[2];
1761 struct timeval s[2], *sp;
1762 int error;
1763
1764 if (uap->tptr != NULL) {
1765 error = copyin(uap->tptr, s32, sizeof(s32));
1766 if (error)
1767 return (error);
1768 CP(s32[0], s[0], tv_sec);
1769 CP(s32[0], s[0], tv_usec);
1770 CP(s32[1], s[1], tv_sec);
1771 CP(s32[1], s[1], tv_usec);
1772 sp = s;
1773 } else
1774 sp = NULL;
1775 return (kern_lutimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE));
1776 }
1777
1778 int
1779 freebsd32_futimes(struct thread *td, struct freebsd32_futimes_args *uap)
1780 {
1781 struct timeval32 s32[2];
1782 struct timeval s[2], *sp;
1783 int error;
1784
1785 if (uap->tptr != NULL) {
1786 error = copyin(uap->tptr, s32, sizeof(s32));
1787 if (error)
1788 return (error);
1789 CP(s32[0], s[0], tv_sec);
1790 CP(s32[0], s[0], tv_usec);
1791 CP(s32[1], s[1], tv_sec);
1792 CP(s32[1], s[1], tv_usec);
1793 sp = s;
1794 } else
1795 sp = NULL;
1796 return (kern_futimes(td, uap->fd, sp, UIO_SYSSPACE));
1797 }
1798
1799 int
1800 freebsd32_futimesat(struct thread *td, struct freebsd32_futimesat_args *uap)
1801 {
1802 struct timeval32 s32[2];
1803 struct timeval s[2], *sp;
1804 int error;
1805
1806 if (uap->times != NULL) {
1807 error = copyin(uap->times, s32, sizeof(s32));
1808 if (error)
1809 return (error);
1810 CP(s32[0], s[0], tv_sec);
1811 CP(s32[0], s[0], tv_usec);
1812 CP(s32[1], s[1], tv_sec);
1813 CP(s32[1], s[1], tv_usec);
1814 sp = s;
1815 } else
1816 sp = NULL;
1817 return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE,
1818 sp, UIO_SYSSPACE));
1819 }
1820
1821 int
1822 freebsd32_futimens(struct thread *td, struct freebsd32_futimens_args *uap)
1823 {
1824 struct timespec32 ts32[2];
1825 struct timespec ts[2], *tsp;
1826 int error;
1827
1828 if (uap->times != NULL) {
1829 error = copyin(uap->times, ts32, sizeof(ts32));
1830 if (error)
1831 return (error);
1832 CP(ts32[0], ts[0], tv_sec);
1833 CP(ts32[0], ts[0], tv_nsec);
1834 CP(ts32[1], ts[1], tv_sec);
1835 CP(ts32[1], ts[1], tv_nsec);
1836 tsp = ts;
1837 } else
1838 tsp = NULL;
1839 return (kern_futimens(td, uap->fd, tsp, UIO_SYSSPACE));
1840 }
1841
1842 int
1843 freebsd32_utimensat(struct thread *td, struct freebsd32_utimensat_args *uap)
1844 {
1845 struct timespec32 ts32[2];
1846 struct timespec ts[2], *tsp;
1847 int error;
1848
1849 if (uap->times != NULL) {
1850 error = copyin(uap->times, ts32, sizeof(ts32));
1851 if (error)
1852 return (error);
1853 CP(ts32[0], ts[0], tv_sec);
1854 CP(ts32[0], ts[0], tv_nsec);
1855 CP(ts32[1], ts[1], tv_sec);
1856 CP(ts32[1], ts[1], tv_nsec);
1857 tsp = ts;
1858 } else
1859 tsp = NULL;
1860 return (kern_utimensat(td, uap->fd, uap->path, UIO_USERSPACE,
1861 tsp, UIO_SYSSPACE, uap->flag));
1862 }
1863
1864 int
1865 freebsd32_adjtime(struct thread *td, struct freebsd32_adjtime_args *uap)
1866 {
1867 struct timeval32 tv32;
1868 struct timeval delta, olddelta, *deltap;
1869 int error;
1870
1871 if (uap->delta) {
1872 error = copyin(uap->delta, &tv32, sizeof(tv32));
1873 if (error)
1874 return (error);
1875 CP(tv32, delta, tv_sec);
1876 CP(tv32, delta, tv_usec);
1877 deltap = δ
1878 } else
1879 deltap = NULL;
1880 error = kern_adjtime(td, deltap, &olddelta);
1881 if (uap->olddelta && error == 0) {
1882 CP(olddelta, tv32, tv_sec);
1883 CP(olddelta, tv32, tv_usec);
1884 error = copyout(&tv32, uap->olddelta, sizeof(tv32));
1885 }
1886 return (error);
1887 }
1888
1889 #ifdef COMPAT_FREEBSD4
1890 int
1891 freebsd4_freebsd32_statfs(struct thread *td, struct freebsd4_freebsd32_statfs_args *uap)
1892 {
1893 struct ostatfs32 s32;
1894 struct statfs *sp;
1895 int error;
1896
1897 sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
1898 error = kern_statfs(td, uap->path, UIO_USERSPACE, sp);
1899 if (error == 0) {
1900 copy_statfs(sp, &s32);
1901 error = copyout(&s32, uap->buf, sizeof(s32));
1902 }
1903 free(sp, M_STATFS);
1904 return (error);
1905 }
1906 #endif
1907
1908 #ifdef COMPAT_FREEBSD4
1909 int
1910 freebsd4_freebsd32_fstatfs(struct thread *td, struct freebsd4_freebsd32_fstatfs_args *uap)
1911 {
1912 struct ostatfs32 s32;
1913 struct statfs *sp;
1914 int error;
1915
1916 sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
1917 error = kern_fstatfs(td, uap->fd, sp);
1918 if (error == 0) {
1919 copy_statfs(sp, &s32);
1920 error = copyout(&s32, uap->buf, sizeof(s32));
1921 }
1922 free(sp, M_STATFS);
1923 return (error);
1924 }
1925 #endif
1926
1927 #ifdef COMPAT_FREEBSD4
1928 int
1929 freebsd4_freebsd32_fhstatfs(struct thread *td, struct freebsd4_freebsd32_fhstatfs_args *uap)
1930 {
1931 struct ostatfs32 s32;
1932 struct statfs *sp;
1933 fhandle_t fh;
1934 int error;
1935
1936 if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
1937 return (error);
1938 sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
1939 error = kern_fhstatfs(td, fh, sp);
1940 if (error == 0) {
1941 copy_statfs(sp, &s32);
1942 error = copyout(&s32, uap->buf, sizeof(s32));
1943 }
1944 free(sp, M_STATFS);
1945 return (error);
1946 }
1947 #endif
1948
1949 int
1950 freebsd32_pread(struct thread *td, struct freebsd32_pread_args *uap)
1951 {
1952
1953 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
1954 PAIR32TO64(off_t, uap->offset)));
1955 }
1956
1957 int
1958 freebsd32_pwrite(struct thread *td, struct freebsd32_pwrite_args *uap)
1959 {
1960
1961 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
1962 PAIR32TO64(off_t, uap->offset)));
1963 }
1964
1965 #ifdef COMPAT_43
1966 int
1967 ofreebsd32_lseek(struct thread *td, struct ofreebsd32_lseek_args *uap)
1968 {
1969
1970 return (kern_lseek(td, uap->fd, uap->offset, uap->whence));
1971 }
1972 #endif
1973
1974 int
1975 freebsd32_lseek(struct thread *td, struct freebsd32_lseek_args *uap)
1976 {
1977 int error;
1978 off_t pos;
1979
1980 error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
1981 uap->whence);
1982 /* Expand the quad return into two parts for eax and edx */
1983 pos = td->td_uretoff.tdu_off;
1984 td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */
1985 td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */
1986 return error;
1987 }
1988
1989 int
1990 freebsd32_truncate(struct thread *td, struct freebsd32_truncate_args *uap)
1991 {
1992
1993 return (kern_truncate(td, uap->path, UIO_USERSPACE,
1994 PAIR32TO64(off_t, uap->length)));
1995 }
1996
1997 #ifdef COMPAT_43
1998 int
1999 ofreebsd32_truncate(struct thread *td, struct ofreebsd32_truncate_args *uap)
2000 {
2001 return (kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
2002 }
2003 #endif
2004
2005 int
2006 freebsd32_ftruncate(struct thread *td, struct freebsd32_ftruncate_args *uap)
2007 {
2008
2009 return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
2010 }
2011
2012 #ifdef COMPAT_43
2013 int
2014 ofreebsd32_ftruncate(struct thread *td, struct ofreebsd32_ftruncate_args *uap)
2015 {
2016 return (kern_ftruncate(td, uap->fd, uap->length));
2017 }
2018
2019 int
2020 ofreebsd32_getdirentries(struct thread *td,
2021 struct ofreebsd32_getdirentries_args *uap)
2022 {
2023 struct ogetdirentries_args ap;
2024 int error;
2025 long loff;
2026 int32_t loff_cut;
2027
2028 ap.fd = uap->fd;
2029 ap.buf = uap->buf;
2030 ap.count = uap->count;
2031 ap.basep = NULL;
2032 error = kern_ogetdirentries(td, &ap, &loff);
2033 if (error == 0) {
2034 loff_cut = loff;
2035 error = copyout(&loff_cut, uap->basep, sizeof(int32_t));
2036 }
2037 return (error);
2038 }
2039 #endif
2040
2041 #if defined(COMPAT_FREEBSD11)
2042 int
2043 freebsd11_freebsd32_getdirentries(struct thread *td,
2044 struct freebsd11_freebsd32_getdirentries_args *uap)
2045 {
2046 long base;
2047 int32_t base32;
2048 int error;
2049
2050 error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
2051 &base, NULL);
2052 if (error)
2053 return (error);
2054 if (uap->basep != NULL) {
2055 base32 = base;
2056 error = copyout(&base32, uap->basep, sizeof(int32_t));
2057 }
2058 return (error);
2059 }
2060 #endif /* COMPAT_FREEBSD11 */
2061
2062 #ifdef COMPAT_FREEBSD6
2063 /* versions with the 'int pad' argument */
2064 int
2065 freebsd6_freebsd32_pread(struct thread *td, struct freebsd6_freebsd32_pread_args *uap)
2066 {
2067
2068 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
2069 PAIR32TO64(off_t, uap->offset)));
2070 }
2071
2072 int
2073 freebsd6_freebsd32_pwrite(struct thread *td, struct freebsd6_freebsd32_pwrite_args *uap)
2074 {
2075
2076 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
2077 PAIR32TO64(off_t, uap->offset)));
2078 }
2079
2080 int
2081 freebsd6_freebsd32_lseek(struct thread *td, struct freebsd6_freebsd32_lseek_args *uap)
2082 {
2083 int error;
2084 off_t pos;
2085
2086 error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
2087 uap->whence);
2088 /* Expand the quad return into two parts for eax and edx */
2089 pos = *(off_t *)(td->td_retval);
2090 td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */
2091 td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */
2092 return error;
2093 }
2094
2095 int
2096 freebsd6_freebsd32_truncate(struct thread *td, struct freebsd6_freebsd32_truncate_args *uap)
2097 {
2098
2099 return (kern_truncate(td, uap->path, UIO_USERSPACE,
2100 PAIR32TO64(off_t, uap->length)));
2101 }
2102
2103 int
2104 freebsd6_freebsd32_ftruncate(struct thread *td, struct freebsd6_freebsd32_ftruncate_args *uap)
2105 {
2106
2107 return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
2108 }
2109 #endif /* COMPAT_FREEBSD6 */
2110
2111 struct sf_hdtr32 {
2112 uint32_t headers;
2113 int hdr_cnt;
2114 uint32_t trailers;
2115 int trl_cnt;
2116 };
2117
2118 static int
2119 freebsd32_do_sendfile(struct thread *td,
2120 struct freebsd32_sendfile_args *uap, int compat)
2121 {
2122 struct sf_hdtr32 hdtr32;
2123 struct sf_hdtr hdtr;
2124 struct uio *hdr_uio, *trl_uio;
2125 struct file *fp;
2126 cap_rights_t rights;
2127 struct iovec32 *iov32;
2128 off_t offset, sbytes;
2129 int error;
2130
2131 offset = PAIR32TO64(off_t, uap->offset);
2132 if (offset < 0)
2133 return (EINVAL);
2134
2135 hdr_uio = trl_uio = NULL;
2136
2137 if (uap->hdtr != NULL) {
2138 error = copyin(uap->hdtr, &hdtr32, sizeof(hdtr32));
2139 if (error)
2140 goto out;
2141 PTRIN_CP(hdtr32, hdtr, headers);
2142 CP(hdtr32, hdtr, hdr_cnt);
2143 PTRIN_CP(hdtr32, hdtr, trailers);
2144 CP(hdtr32, hdtr, trl_cnt);
2145
2146 if (hdtr.headers != NULL) {
2147 iov32 = PTRIN(hdtr32.headers);
2148 error = freebsd32_copyinuio(iov32,
2149 hdtr32.hdr_cnt, &hdr_uio);
2150 if (error)
2151 goto out;
2152 #ifdef COMPAT_FREEBSD4
2153 /*
2154 * In FreeBSD < 5.0 the nbytes to send also included
2155 * the header. If compat is specified subtract the
2156 * header size from nbytes.
2157 */
2158 if (compat) {
2159 if (uap->nbytes > hdr_uio->uio_resid)
2160 uap->nbytes -= hdr_uio->uio_resid;
2161 else
2162 uap->nbytes = 0;
2163 }
2164 #endif
2165 }
2166 if (hdtr.trailers != NULL) {
2167 iov32 = PTRIN(hdtr32.trailers);
2168 error = freebsd32_copyinuio(iov32,
2169 hdtr32.trl_cnt, &trl_uio);
2170 if (error)
2171 goto out;
2172 }
2173 }
2174
2175 AUDIT_ARG_FD(uap->fd);
2176
2177 if ((error = fget_read(td, uap->fd,
2178 cap_rights_init_one(&rights, CAP_PREAD), &fp)) != 0)
2179 goto out;
2180
2181 error = fo_sendfile(fp, uap->s, hdr_uio, trl_uio, offset,
2182 uap->nbytes, &sbytes, uap->flags, td);
2183 fdrop(fp, td);
2184
2185 if (uap->sbytes != NULL)
2186 copyout(&sbytes, uap->sbytes, sizeof(off_t));
2187
2188 out:
2189 if (hdr_uio)
2190 free(hdr_uio, M_IOV);
2191 if (trl_uio)
2192 free(trl_uio, M_IOV);
2193 return (error);
2194 }
2195
2196 #ifdef COMPAT_FREEBSD4
2197 int
2198 freebsd4_freebsd32_sendfile(struct thread *td,
2199 struct freebsd4_freebsd32_sendfile_args *uap)
2200 {
2201 return (freebsd32_do_sendfile(td,
2202 (struct freebsd32_sendfile_args *)uap, 1));
2203 }
2204 #endif
2205
2206 int
2207 freebsd32_sendfile(struct thread *td, struct freebsd32_sendfile_args *uap)
2208 {
2209
2210 return (freebsd32_do_sendfile(td, uap, 0));
2211 }
2212
2213 static void
2214 copy_stat(struct stat *in, struct stat32 *out)
2215 {
2216
2217 #ifndef __amd64__
2218 /*
2219 * 32-bit architectures other than i386 have 64-bit time_t. This
2220 * results in struct timespec32 with 12 bytes for tv_sec and tv_nsec,
2221 * and 4 bytes of padding. Zero the padding holes in struct stat32.
2222 */
2223 bzero(&out->st_atim, sizeof(out->st_atim));
2224 bzero(&out->st_mtim, sizeof(out->st_mtim));
2225 bzero(&out->st_ctim, sizeof(out->st_ctim));
2226 bzero(&out->st_birthtim, sizeof(out->st_birthtim));
2227 #endif
2228 CP(*in, *out, st_dev);
2229 CP(*in, *out, st_ino);
2230 CP(*in, *out, st_mode);
2231 CP(*in, *out, st_nlink);
2232 CP(*in, *out, st_uid);
2233 CP(*in, *out, st_gid);
2234 CP(*in, *out, st_rdev);
2235 TS_CP(*in, *out, st_atim);
2236 TS_CP(*in, *out, st_mtim);
2237 TS_CP(*in, *out, st_ctim);
2238 CP(*in, *out, st_size);
2239 CP(*in, *out, st_blocks);
2240 CP(*in, *out, st_blksize);
2241 CP(*in, *out, st_flags);
2242 CP(*in, *out, st_gen);
2243 TS_CP(*in, *out, st_birthtim);
2244 out->st_padding0 = 0;
2245 out->st_padding1 = 0;
2246 #ifdef __STAT32_TIME_T_EXT
2247 out->st_atim_ext = 0;
2248 out->st_mtim_ext = 0;
2249 out->st_ctim_ext = 0;
2250 out->st_btim_ext = 0;
2251 #endif
2252 bzero(out->st_spare, sizeof(out->st_spare));
2253 }
2254
2255 #ifdef COMPAT_43
2256 static void
2257 copy_ostat(struct stat *in, struct ostat32 *out)
2258 {
2259
2260 bzero(out, sizeof(*out));
2261 CP(*in, *out, st_dev);
2262 CP(*in, *out, st_ino);
2263 CP(*in, *out, st_mode);
2264 CP(*in, *out, st_nlink);
2265 CP(*in, *out, st_uid);
2266 CP(*in, *out, st_gid);
2267 CP(*in, *out, st_rdev);
2268 out->st_size = MIN(in->st_size, INT32_MAX);
2269 TS_CP(*in, *out, st_atim);
2270 TS_CP(*in, *out, st_mtim);
2271 TS_CP(*in, *out, st_ctim);
2272 CP(*in, *out, st_blksize);
2273 CP(*in, *out, st_blocks);
2274 CP(*in, *out, st_flags);
2275 CP(*in, *out, st_gen);
2276 }
2277 #endif
2278
2279 #ifdef COMPAT_43
2280 int
2281 ofreebsd32_stat(struct thread *td, struct ofreebsd32_stat_args *uap)
2282 {
2283 struct stat sb;
2284 struct ostat32 sb32;
2285 int error;
2286
2287 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2288 &sb, NULL);
2289 if (error)
2290 return (error);
2291 copy_ostat(&sb, &sb32);
2292 error = copyout(&sb32, uap->ub, sizeof (sb32));
2293 return (error);
2294 }
2295 #endif
2296
2297 int
2298 freebsd32_fstat(struct thread *td, struct freebsd32_fstat_args *uap)
2299 {
2300 struct stat ub;
2301 struct stat32 ub32;
2302 int error;
2303
2304 error = kern_fstat(td, uap->fd, &ub);
2305 if (error)
2306 return (error);
2307 copy_stat(&ub, &ub32);
2308 error = copyout(&ub32, uap->sb, sizeof(ub32));
2309 return (error);
2310 }
2311
2312 #ifdef COMPAT_43
2313 int
2314 ofreebsd32_fstat(struct thread *td, struct ofreebsd32_fstat_args *uap)
2315 {
2316 struct stat ub;
2317 struct ostat32 ub32;
2318 int error;
2319
2320 error = kern_fstat(td, uap->fd, &ub);
2321 if (error)
2322 return (error);
2323 copy_ostat(&ub, &ub32);
2324 error = copyout(&ub32, uap->sb, sizeof(ub32));
2325 return (error);
2326 }
2327 #endif
2328
2329 int
2330 freebsd32_fstatat(struct thread *td, struct freebsd32_fstatat_args *uap)
2331 {
2332 struct stat ub;
2333 struct stat32 ub32;
2334 int error;
2335
2336 error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
2337 &ub, NULL);
2338 if (error)
2339 return (error);
2340 copy_stat(&ub, &ub32);
2341 error = copyout(&ub32, uap->buf, sizeof(ub32));
2342 return (error);
2343 }
2344
2345 #ifdef COMPAT_43
2346 int
2347 ofreebsd32_lstat(struct thread *td, struct ofreebsd32_lstat_args *uap)
2348 {
2349 struct stat sb;
2350 struct ostat32 sb32;
2351 int error;
2352
2353 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2354 UIO_USERSPACE, &sb, NULL);
2355 if (error)
2356 return (error);
2357 copy_ostat(&sb, &sb32);
2358 error = copyout(&sb32, uap->ub, sizeof (sb32));
2359 return (error);
2360 }
2361 #endif
2362
2363 int
2364 freebsd32_fhstat(struct thread *td, struct freebsd32_fhstat_args *uap)
2365 {
2366 struct stat sb;
2367 struct stat32 sb32;
2368 struct fhandle fh;
2369 int error;
2370
2371 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
2372 if (error != 0)
2373 return (error);
2374 error = kern_fhstat(td, fh, &sb);
2375 if (error != 0)
2376 return (error);
2377 copy_stat(&sb, &sb32);
2378 error = copyout(&sb32, uap->sb, sizeof (sb32));
2379 return (error);
2380 }
2381
2382 #if defined(COMPAT_FREEBSD11)
2383 extern int ino64_trunc_error;
2384
2385 static int
2386 freebsd11_cvtstat32(struct stat *in, struct freebsd11_stat32 *out)
2387 {
2388
2389 #ifndef __amd64__
2390 /*
2391 * 32-bit architectures other than i386 have 64-bit time_t. This
2392 * results in struct timespec32 with 12 bytes for tv_sec and tv_nsec,
2393 * and 4 bytes of padding. Zero the padding holes in freebsd11_stat32.
2394 */
2395 bzero(&out->st_atim, sizeof(out->st_atim));
2396 bzero(&out->st_mtim, sizeof(out->st_mtim));
2397 bzero(&out->st_ctim, sizeof(out->st_ctim));
2398 bzero(&out->st_birthtim, sizeof(out->st_birthtim));
2399 #endif
2400
2401 CP(*in, *out, st_ino);
2402 if (in->st_ino != out->st_ino) {
2403 switch (ino64_trunc_error) {
2404 default:
2405 case 0:
2406 break;
2407 case 1:
2408 return (EOVERFLOW);
2409 case 2:
2410 out->st_ino = UINT32_MAX;
2411 break;
2412 }
2413 }
2414 CP(*in, *out, st_nlink);
2415 if (in->st_nlink != out->st_nlink) {
2416 switch (ino64_trunc_error) {
2417 default:
2418 case 0:
2419 break;
2420 case 1:
2421 return (EOVERFLOW);
2422 case 2:
2423 out->st_nlink = UINT16_MAX;
2424 break;
2425 }
2426 }
2427 out->st_dev = in->st_dev;
2428 if (out->st_dev != in->st_dev) {
2429 switch (ino64_trunc_error) {
2430 default:
2431 break;
2432 case 1:
2433 return (EOVERFLOW);
2434 }
2435 }
2436 CP(*in, *out, st_mode);
2437 CP(*in, *out, st_uid);
2438 CP(*in, *out, st_gid);
2439 out->st_rdev = in->st_rdev;
2440 if (out->st_rdev != in->st_rdev) {
2441 switch (ino64_trunc_error) {
2442 default:
2443 break;
2444 case 1:
2445 return (EOVERFLOW);
2446 }
2447 }
2448 TS_CP(*in, *out, st_atim);
2449 TS_CP(*in, *out, st_mtim);
2450 TS_CP(*in, *out, st_ctim);
2451 CP(*in, *out, st_size);
2452 CP(*in, *out, st_blocks);
2453 CP(*in, *out, st_blksize);
2454 CP(*in, *out, st_flags);
2455 CP(*in, *out, st_gen);
2456 TS_CP(*in, *out, st_birthtim);
2457 out->st_lspare = 0;
2458 bzero((char *)&out->st_birthtim + sizeof(out->st_birthtim),
2459 sizeof(*out) - offsetof(struct freebsd11_stat32,
2460 st_birthtim) - sizeof(out->st_birthtim));
2461 return (0);
2462 }
2463
2464 int
2465 freebsd11_freebsd32_stat(struct thread *td,
2466 struct freebsd11_freebsd32_stat_args *uap)
2467 {
2468 struct stat sb;
2469 struct freebsd11_stat32 sb32;
2470 int error;
2471
2472 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2473 &sb, NULL);
2474 if (error != 0)
2475 return (error);
2476 error = freebsd11_cvtstat32(&sb, &sb32);
2477 if (error == 0)
2478 error = copyout(&sb32, uap->ub, sizeof (sb32));
2479 return (error);
2480 }
2481
2482 int
2483 freebsd11_freebsd32_fstat(struct thread *td,
2484 struct freebsd11_freebsd32_fstat_args *uap)
2485 {
2486 struct stat sb;
2487 struct freebsd11_stat32 sb32;
2488 int error;
2489
2490 error = kern_fstat(td, uap->fd, &sb);
2491 if (error != 0)
2492 return (error);
2493 error = freebsd11_cvtstat32(&sb, &sb32);
2494 if (error == 0)
2495 error = copyout(&sb32, uap->sb, sizeof (sb32));
2496 return (error);
2497 }
2498
2499 int
2500 freebsd11_freebsd32_fstatat(struct thread *td,
2501 struct freebsd11_freebsd32_fstatat_args *uap)
2502 {
2503 struct stat sb;
2504 struct freebsd11_stat32 sb32;
2505 int error;
2506
2507 error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
2508 &sb, NULL);
2509 if (error != 0)
2510 return (error);
2511 error = freebsd11_cvtstat32(&sb, &sb32);
2512 if (error == 0)
2513 error = copyout(&sb32, uap->buf, sizeof (sb32));
2514 return (error);
2515 }
2516
2517 int
2518 freebsd11_freebsd32_lstat(struct thread *td,
2519 struct freebsd11_freebsd32_lstat_args *uap)
2520 {
2521 struct stat sb;
2522 struct freebsd11_stat32 sb32;
2523 int error;
2524
2525 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2526 UIO_USERSPACE, &sb, NULL);
2527 if (error != 0)
2528 return (error);
2529 error = freebsd11_cvtstat32(&sb, &sb32);
2530 if (error == 0)
2531 error = copyout(&sb32, uap->ub, sizeof (sb32));
2532 return (error);
2533 }
2534
2535 int
2536 freebsd11_freebsd32_fhstat(struct thread *td,
2537 struct freebsd11_freebsd32_fhstat_args *uap)
2538 {
2539 struct stat sb;
2540 struct freebsd11_stat32 sb32;
2541 struct fhandle fh;
2542 int error;
2543
2544 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
2545 if (error != 0)
2546 return (error);
2547 error = kern_fhstat(td, fh, &sb);
2548 if (error != 0)
2549 return (error);
2550 error = freebsd11_cvtstat32(&sb, &sb32);
2551 if (error == 0)
2552 error = copyout(&sb32, uap->sb, sizeof (sb32));
2553 return (error);
2554 }
2555
2556 static int
2557 freebsd11_cvtnstat32(struct stat *sb, struct nstat32 *nsb32)
2558 {
2559 struct nstat nsb;
2560 int error;
2561
2562 error = freebsd11_cvtnstat(sb, &nsb);
2563 if (error != 0)
2564 return (error);
2565
2566 bzero(nsb32, sizeof(*nsb32));
2567 CP(nsb, *nsb32, st_dev);
2568 CP(nsb, *nsb32, st_ino);
2569 CP(nsb, *nsb32, st_mode);
2570 CP(nsb, *nsb32, st_nlink);
2571 CP(nsb, *nsb32, st_uid);
2572 CP(nsb, *nsb32, st_gid);
2573 CP(nsb, *nsb32, st_rdev);
2574 CP(nsb, *nsb32, st_atim.tv_sec);
2575 CP(nsb, *nsb32, st_atim.tv_nsec);
2576 CP(nsb, *nsb32, st_mtim.tv_sec);
2577 CP(nsb, *nsb32, st_mtim.tv_nsec);
2578 CP(nsb, *nsb32, st_ctim.tv_sec);
2579 CP(nsb, *nsb32, st_ctim.tv_nsec);
2580 CP(nsb, *nsb32, st_size);
2581 CP(nsb, *nsb32, st_blocks);
2582 CP(nsb, *nsb32, st_blksize);
2583 CP(nsb, *nsb32, st_flags);
2584 CP(nsb, *nsb32, st_gen);
2585 CP(nsb, *nsb32, st_birthtim.tv_sec);
2586 CP(nsb, *nsb32, st_birthtim.tv_nsec);
2587 return (0);
2588 }
2589
2590 int
2591 freebsd11_freebsd32_nstat(struct thread *td,
2592 struct freebsd11_freebsd32_nstat_args *uap)
2593 {
2594 struct stat sb;
2595 struct nstat32 nsb;
2596 int error;
2597
2598 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2599 &sb, NULL);
2600 if (error != 0)
2601 return (error);
2602 error = freebsd11_cvtnstat32(&sb, &nsb);
2603 if (error != 0)
2604 error = copyout(&nsb, uap->ub, sizeof (nsb));
2605 return (error);
2606 }
2607
2608 int
2609 freebsd11_freebsd32_nlstat(struct thread *td,
2610 struct freebsd11_freebsd32_nlstat_args *uap)
2611 {
2612 struct stat sb;
2613 struct nstat32 nsb;
2614 int error;
2615
2616 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2617 UIO_USERSPACE, &sb, NULL);
2618 if (error != 0)
2619 return (error);
2620 error = freebsd11_cvtnstat32(&sb, &nsb);
2621 if (error == 0)
2622 error = copyout(&nsb, uap->ub, sizeof (nsb));
2623 return (error);
2624 }
2625
2626 int
2627 freebsd11_freebsd32_nfstat(struct thread *td,
2628 struct freebsd11_freebsd32_nfstat_args *uap)
2629 {
2630 struct nstat32 nub;
2631 struct stat ub;
2632 int error;
2633
2634 error = kern_fstat(td, uap->fd, &ub);
2635 if (error != 0)
2636 return (error);
2637 error = freebsd11_cvtnstat32(&ub, &nub);
2638 if (error == 0)
2639 error = copyout(&nub, uap->sb, sizeof(nub));
2640 return (error);
2641 }
2642 #endif
2643
2644 int
2645 freebsd32___sysctl(struct thread *td, struct freebsd32___sysctl_args *uap)
2646 {
2647 int error, name[CTL_MAXNAME];
2648 size_t j, oldlen;
2649 uint32_t tmp;
2650
2651 if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
2652 return (EINVAL);
2653 error = copyin(uap->name, name, uap->namelen * sizeof(int));
2654 if (error)
2655 return (error);
2656 if (uap->oldlenp) {
2657 error = fueword32(uap->oldlenp, &tmp);
2658 oldlen = tmp;
2659 } else {
2660 oldlen = 0;
2661 }
2662 if (error != 0)
2663 return (EFAULT);
2664 error = userland_sysctl(td, name, uap->namelen,
2665 uap->old, &oldlen, 1,
2666 uap->new, uap->newlen, &j, SCTL_MASK32);
2667 if (error)
2668 return (error);
2669 if (uap->oldlenp)
2670 suword32(uap->oldlenp, j);
2671 return (0);
2672 }
2673
2674 int
2675 freebsd32___sysctlbyname(struct thread *td,
2676 struct freebsd32___sysctlbyname_args *uap)
2677 {
2678 size_t oldlen, rv;
2679 int error;
2680 uint32_t tmp;
2681
2682 if (uap->oldlenp != NULL) {
2683 error = fueword32(uap->oldlenp, &tmp);
2684 oldlen = tmp;
2685 } else {
2686 error = oldlen = 0;
2687 }
2688 if (error != 0)
2689 return (EFAULT);
2690 error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old,
2691 &oldlen, uap->new, uap->newlen, &rv, SCTL_MASK32, 1);
2692 if (error != 0)
2693 return (error);
2694 if (uap->oldlenp != NULL)
2695 error = suword32(uap->oldlenp, rv);
2696
2697 return (error);
2698 }
2699
2700 int
2701 freebsd32_jail(struct thread *td, struct freebsd32_jail_args *uap)
2702 {
2703 uint32_t version;
2704 int error;
2705 struct jail j;
2706
2707 error = copyin(uap->jail, &version, sizeof(uint32_t));
2708 if (error)
2709 return (error);
2710
2711 switch (version) {
2712 case 0:
2713 {
2714 /* FreeBSD single IPv4 jails. */
2715 struct jail32_v0 j32_v0;
2716
2717 bzero(&j, sizeof(struct jail));
2718 error = copyin(uap->jail, &j32_v0, sizeof(struct jail32_v0));
2719 if (error)
2720 return (error);
2721 CP(j32_v0, j, version);
2722 PTRIN_CP(j32_v0, j, path);
2723 PTRIN_CP(j32_v0, j, hostname);
2724 j.ip4s = htonl(j32_v0.ip_number); /* jail_v0 is host order */
2725 break;
2726 }
2727
2728 case 1:
2729 /*
2730 * Version 1 was used by multi-IPv4 jail implementations
2731 * that never made it into the official kernel.
2732 */
2733 return (EINVAL);
2734
2735 case 2: /* JAIL_API_VERSION */
2736 {
2737 /* FreeBSD multi-IPv4/IPv6,noIP jails. */
2738 struct jail32 j32;
2739
2740 error = copyin(uap->jail, &j32, sizeof(struct jail32));
2741 if (error)
2742 return (error);
2743 CP(j32, j, version);
2744 PTRIN_CP(j32, j, path);
2745 PTRIN_CP(j32, j, hostname);
2746 PTRIN_CP(j32, j, jailname);
2747 CP(j32, j, ip4s);
2748 CP(j32, j, ip6s);
2749 PTRIN_CP(j32, j, ip4);
2750 PTRIN_CP(j32, j, ip6);
2751 break;
2752 }
2753
2754 default:
2755 /* Sci-Fi jails are not supported, sorry. */
2756 return (EINVAL);
2757 }
2758 return (kern_jail(td, &j));
2759 }
2760
2761 int
2762 freebsd32_jail_set(struct thread *td, struct freebsd32_jail_set_args *uap)
2763 {
2764 struct uio *auio;
2765 int error;
2766
2767 /* Check that we have an even number of iovecs. */
2768 if (uap->iovcnt & 1)
2769 return (EINVAL);
2770
2771 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2772 if (error)
2773 return (error);
2774 error = kern_jail_set(td, auio, uap->flags);
2775 free(auio, M_IOV);
2776 return (error);
2777 }
2778
2779 int
2780 freebsd32_jail_get(struct thread *td, struct freebsd32_jail_get_args *uap)
2781 {
2782 struct iovec32 iov32;
2783 struct uio *auio;
2784 int error, i;
2785
2786 /* Check that we have an even number of iovecs. */
2787 if (uap->iovcnt & 1)
2788 return (EINVAL);
2789
2790 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2791 if (error)
2792 return (error);
2793 error = kern_jail_get(td, auio, uap->flags);
2794 if (error == 0)
2795 for (i = 0; i < uap->iovcnt; i++) {
2796 PTROUT_CP(auio->uio_iov[i], iov32, iov_base);
2797 CP(auio->uio_iov[i], iov32, iov_len);
2798 error = copyout(&iov32, uap->iovp + i, sizeof(iov32));
2799 if (error != 0)
2800 break;
2801 }
2802 free(auio, M_IOV);
2803 return (error);
2804 }
2805
2806 int
2807 freebsd32_sigaction(struct thread *td, struct freebsd32_sigaction_args *uap)
2808 {
2809 struct sigaction32 s32;
2810 struct sigaction sa, osa, *sap;
2811 int error;
2812
2813 if (uap->act) {
2814 error = copyin(uap->act, &s32, sizeof(s32));
2815 if (error)
2816 return (error);
2817 sa.sa_handler = PTRIN(s32.sa_u);
2818 CP(s32, sa, sa_flags);
2819 CP(s32, sa, sa_mask);
2820 sap = &sa;
2821 } else
2822 sap = NULL;
2823 error = kern_sigaction(td, uap->sig, sap, &osa, 0);
2824 if (error == 0 && uap->oact != NULL) {
2825 s32.sa_u = PTROUT(osa.sa_handler);
2826 CP(osa, s32, sa_flags);
2827 CP(osa, s32, sa_mask);
2828 error = copyout(&s32, uap->oact, sizeof(s32));
2829 }
2830 return (error);
2831 }
2832
2833 #ifdef COMPAT_FREEBSD4
2834 int
2835 freebsd4_freebsd32_sigaction(struct thread *td,
2836 struct freebsd4_freebsd32_sigaction_args *uap)
2837 {
2838 struct sigaction32 s32;
2839 struct sigaction sa, osa, *sap;
2840 int error;
2841
2842 if (uap->act) {
2843 error = copyin(uap->act, &s32, sizeof(s32));
2844 if (error)
2845 return (error);
2846 sa.sa_handler = PTRIN(s32.sa_u);
2847 CP(s32, sa, sa_flags);
2848 CP(s32, sa, sa_mask);
2849 sap = &sa;
2850 } else
2851 sap = NULL;
2852 error = kern_sigaction(td, uap->sig, sap, &osa, KSA_FREEBSD4);
2853 if (error == 0 && uap->oact != NULL) {
2854 s32.sa_u = PTROUT(osa.sa_handler);
2855 CP(osa, s32, sa_flags);
2856 CP(osa, s32, sa_mask);
2857 error = copyout(&s32, uap->oact, sizeof(s32));
2858 }
2859 return (error);
2860 }
2861 #endif
2862
2863 #ifdef COMPAT_43
2864 struct osigaction32 {
2865 uint32_t sa_u;
2866 osigset_t sa_mask;
2867 int sa_flags;
2868 };
2869
2870 #define ONSIG 32
2871
2872 int
2873 ofreebsd32_sigaction(struct thread *td,
2874 struct ofreebsd32_sigaction_args *uap)
2875 {
2876 struct osigaction32 s32;
2877 struct sigaction sa, osa, *sap;
2878 int error;
2879
2880 if (uap->signum <= 0 || uap->signum >= ONSIG)
2881 return (EINVAL);
2882
2883 if (uap->nsa) {
2884 error = copyin(uap->nsa, &s32, sizeof(s32));
2885 if (error)
2886 return (error);
2887 sa.sa_handler = PTRIN(s32.sa_u);
2888 CP(s32, sa, sa_flags);
2889 OSIG2SIG(s32.sa_mask, sa.sa_mask);
2890 sap = &sa;
2891 } else
2892 sap = NULL;
2893 error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2894 if (error == 0 && uap->osa != NULL) {
2895 s32.sa_u = PTROUT(osa.sa_handler);
2896 CP(osa, s32, sa_flags);
2897 SIG2OSIG(osa.sa_mask, s32.sa_mask);
2898 error = copyout(&s32, uap->osa, sizeof(s32));
2899 }
2900 return (error);
2901 }
2902
2903 struct sigvec32 {
2904 uint32_t sv_handler;
2905 int sv_mask;
2906 int sv_flags;
2907 };
2908
2909 int
2910 ofreebsd32_sigvec(struct thread *td,
2911 struct ofreebsd32_sigvec_args *uap)
2912 {
2913 struct sigvec32 vec;
2914 struct sigaction sa, osa, *sap;
2915 int error;
2916
2917 if (uap->signum <= 0 || uap->signum >= ONSIG)
2918 return (EINVAL);
2919
2920 if (uap->nsv) {
2921 error = copyin(uap->nsv, &vec, sizeof(vec));
2922 if (error)
2923 return (error);
2924 sa.sa_handler = PTRIN(vec.sv_handler);
2925 OSIG2SIG(vec.sv_mask, sa.sa_mask);
2926 sa.sa_flags = vec.sv_flags;
2927 sa.sa_flags ^= SA_RESTART;
2928 sap = &sa;
2929 } else
2930 sap = NULL;
2931 error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2932 if (error == 0 && uap->osv != NULL) {
2933 vec.sv_handler = PTROUT(osa.sa_handler);
2934 SIG2OSIG(osa.sa_mask, vec.sv_mask);
2935 vec.sv_flags = osa.sa_flags;
2936 vec.sv_flags &= ~SA_NOCLDWAIT;
2937 vec.sv_flags ^= SA_RESTART;
2938 error = copyout(&vec, uap->osv, sizeof(vec));
2939 }
2940 return (error);
2941 }
2942
2943 struct sigstack32 {
2944 uint32_t ss_sp;
2945 int ss_onstack;
2946 };
2947
2948 int
2949 ofreebsd32_sigstack(struct thread *td,
2950 struct ofreebsd32_sigstack_args *uap)
2951 {
2952 struct sigstack32 s32;
2953 struct sigstack nss, oss;
2954 int error = 0, unss;
2955
2956 if (uap->nss != NULL) {
2957 error = copyin(uap->nss, &s32, sizeof(s32));
2958 if (error)
2959 return (error);
2960 nss.ss_sp = PTRIN(s32.ss_sp);
2961 CP(s32, nss, ss_onstack);
2962 unss = 1;
2963 } else {
2964 unss = 0;
2965 }
2966 oss.ss_sp = td->td_sigstk.ss_sp;
2967 oss.ss_onstack = sigonstack(cpu_getstack(td));
2968 if (unss) {
2969 td->td_sigstk.ss_sp = nss.ss_sp;
2970 td->td_sigstk.ss_size = 0;
2971 td->td_sigstk.ss_flags |= (nss.ss_onstack & SS_ONSTACK);
2972 td->td_pflags |= TDP_ALTSTACK;
2973 }
2974 if (uap->oss != NULL) {
2975 s32.ss_sp = PTROUT(oss.ss_sp);
2976 CP(oss, s32, ss_onstack);
2977 error = copyout(&s32, uap->oss, sizeof(s32));
2978 }
2979 return (error);
2980 }
2981 #endif
2982
2983 int
2984 freebsd32_nanosleep(struct thread *td, struct freebsd32_nanosleep_args *uap)
2985 {
2986
2987 return (freebsd32_user_clock_nanosleep(td, CLOCK_REALTIME,
2988 TIMER_RELTIME, uap->rqtp, uap->rmtp));
2989 }
2990
2991 int
2992 freebsd32_clock_nanosleep(struct thread *td,
2993 struct freebsd32_clock_nanosleep_args *uap)
2994 {
2995 int error;
2996
2997 error = freebsd32_user_clock_nanosleep(td, uap->clock_id, uap->flags,
2998 uap->rqtp, uap->rmtp);
2999 return (kern_posix_error(td, error));
3000 }
3001
3002 static int
3003 freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id,
3004 int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp)
3005 {
3006 struct timespec32 rmt32, rqt32;
3007 struct timespec rmt, rqt;
3008 int error, error2;
3009
3010 error = copyin(ua_rqtp, &rqt32, sizeof(rqt32));
3011 if (error)
3012 return (error);
3013
3014 CP(rqt32, rqt, tv_sec);
3015 CP(rqt32, rqt, tv_nsec);
3016
3017 error = kern_clock_nanosleep(td, clock_id, flags, &rqt, &rmt);
3018 if (error == EINTR && ua_rmtp != NULL && (flags & TIMER_ABSTIME) == 0) {
3019 CP(rmt, rmt32, tv_sec);
3020 CP(rmt, rmt32, tv_nsec);
3021
3022 error2 = copyout(&rmt32, ua_rmtp, sizeof(rmt32));
3023 if (error2 != 0)
3024 error = error2;
3025 }
3026 return (error);
3027 }
3028
3029 int
3030 freebsd32_clock_gettime(struct thread *td,
3031 struct freebsd32_clock_gettime_args *uap)
3032 {
3033 struct timespec ats;
3034 struct timespec32 ats32;
3035 int error;
3036
3037 error = kern_clock_gettime(td, uap->clock_id, &ats);
3038 if (error == 0) {
3039 CP(ats, ats32, tv_sec);
3040 CP(ats, ats32, tv_nsec);
3041 error = copyout(&ats32, uap->tp, sizeof(ats32));
3042 }
3043 return (error);
3044 }
3045
3046 int
3047 freebsd32_clock_settime(struct thread *td,
3048 struct freebsd32_clock_settime_args *uap)
3049 {
3050 struct timespec ats;
3051 struct timespec32 ats32;
3052 int error;
3053
3054 error = copyin(uap->tp, &ats32, sizeof(ats32));
3055 if (error)
3056 return (error);
3057 CP(ats32, ats, tv_sec);
3058 CP(ats32, ats, tv_nsec);
3059
3060 return (kern_clock_settime(td, uap->clock_id, &ats));
3061 }
3062
3063 int
3064 freebsd32_clock_getres(struct thread *td,
3065 struct freebsd32_clock_getres_args *uap)
3066 {
3067 struct timespec ts;
3068 struct timespec32 ts32;
3069 int error;
3070
3071 if (uap->tp == NULL)
3072 return (0);
3073 error = kern_clock_getres(td, uap->clock_id, &ts);
3074 if (error == 0) {
3075 CP(ts, ts32, tv_sec);
3076 CP(ts, ts32, tv_nsec);
3077 error = copyout(&ts32, uap->tp, sizeof(ts32));
3078 }
3079 return (error);
3080 }
3081
3082 int freebsd32_ktimer_create(struct thread *td,
3083 struct freebsd32_ktimer_create_args *uap)
3084 {
3085 struct sigevent32 ev32;
3086 struct sigevent ev, *evp;
3087 int error, id;
3088
3089 if (uap->evp == NULL) {
3090 evp = NULL;
3091 } else {
3092 evp = &ev;
3093 error = copyin(uap->evp, &ev32, sizeof(ev32));
3094 if (error != 0)
3095 return (error);
3096 error = convert_sigevent32(&ev32, &ev);
3097 if (error != 0)
3098 return (error);
3099 }
3100 error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1);
3101 if (error == 0) {
3102 error = copyout(&id, uap->timerid, sizeof(int));
3103 if (error != 0)
3104 kern_ktimer_delete(td, id);
3105 }
3106 return (error);
3107 }
3108
3109 int
3110 freebsd32_ktimer_settime(struct thread *td,
3111 struct freebsd32_ktimer_settime_args *uap)
3112 {
3113 struct itimerspec32 val32, oval32;
3114 struct itimerspec val, oval, *ovalp;
3115 int error;
3116
3117 error = copyin(uap->value, &val32, sizeof(val32));
3118 if (error != 0)
3119 return (error);
3120 ITS_CP(val32, val);
3121 ovalp = uap->ovalue != NULL ? &oval : NULL;
3122 error = kern_ktimer_settime(td, uap->timerid, uap->flags, &val, ovalp);
3123 if (error == 0 && uap->ovalue != NULL) {
3124 ITS_CP(oval, oval32);
3125 error = copyout(&oval32, uap->ovalue, sizeof(oval32));
3126 }
3127 return (error);
3128 }
3129
3130 int
3131 freebsd32_ktimer_gettime(struct thread *td,
3132 struct freebsd32_ktimer_gettime_args *uap)
3133 {
3134 struct itimerspec32 val32;
3135 struct itimerspec val;
3136 int error;
3137
3138 error = kern_ktimer_gettime(td, uap->timerid, &val);
3139 if (error == 0) {
3140 ITS_CP(val, val32);
3141 error = copyout(&val32, uap->value, sizeof(val32));
3142 }
3143 return (error);
3144 }
3145
3146 int
3147 freebsd32_clock_getcpuclockid2(struct thread *td,
3148 struct freebsd32_clock_getcpuclockid2_args *uap)
3149 {
3150 clockid_t clk_id;
3151 int error;
3152
3153 error = kern_clock_getcpuclockid2(td, PAIR32TO64(id_t, uap->id),
3154 uap->which, &clk_id);
3155 if (error == 0)
3156 error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t));
3157 return (error);
3158 }
3159
3160 int
3161 freebsd32_thr_new(struct thread *td,
3162 struct freebsd32_thr_new_args *uap)
3163 {
3164 struct thr_param32 param32;
3165 struct thr_param param;
3166 int error;
3167
3168 if (uap->param_size < 0 ||
3169 uap->param_size > sizeof(struct thr_param32))
3170 return (EINVAL);
3171 bzero(¶m, sizeof(struct thr_param));
3172 bzero(¶m32, sizeof(struct thr_param32));
3173 error = copyin(uap->param, ¶m32, uap->param_size);
3174 if (error != 0)
3175 return (error);
3176 param.start_func = PTRIN(param32.start_func);
3177 param.arg = PTRIN(param32.arg);
3178 param.stack_base = PTRIN(param32.stack_base);
3179 param.stack_size = param32.stack_size;
3180 param.tls_base = PTRIN(param32.tls_base);
3181 param.tls_size = param32.tls_size;
3182 param.child_tid = PTRIN(param32.child_tid);
3183 param.parent_tid = PTRIN(param32.parent_tid);
3184 param.flags = param32.flags;
3185 param.rtp = PTRIN(param32.rtp);
3186 param.spare[0] = PTRIN(param32.spare[0]);
3187 param.spare[1] = PTRIN(param32.spare[1]);
3188 param.spare[2] = PTRIN(param32.spare[2]);
3189
3190 return (kern_thr_new(td, ¶m));
3191 }
3192
3193 int
3194 freebsd32_thr_suspend(struct thread *td, struct freebsd32_thr_suspend_args *uap)
3195 {
3196 struct timespec32 ts32;
3197 struct timespec ts, *tsp;
3198 int error;
3199
3200 error = 0;
3201 tsp = NULL;
3202 if (uap->timeout != NULL) {
3203 error = copyin((const void *)uap->timeout, (void *)&ts32,
3204 sizeof(struct timespec32));
3205 if (error != 0)
3206 return (error);
3207 ts.tv_sec = ts32.tv_sec;
3208 ts.tv_nsec = ts32.tv_nsec;
3209 tsp = &ts;
3210 }
3211 return (kern_thr_suspend(td, tsp));
3212 }
3213
3214 void
3215 siginfo_to_siginfo32(const siginfo_t *src, struct siginfo32 *dst)
3216 {
3217 bzero(dst, sizeof(*dst));
3218 dst->si_signo = src->si_signo;
3219 dst->si_errno = src->si_errno;
3220 dst->si_code = src->si_code;
3221 dst->si_pid = src->si_pid;
3222 dst->si_uid = src->si_uid;
3223 dst->si_status = src->si_status;
3224 dst->si_addr = (uintptr_t)src->si_addr;
3225 dst->si_value.sival_int = src->si_value.sival_int;
3226 dst->si_timerid = src->si_timerid;
3227 dst->si_overrun = src->si_overrun;
3228 }
3229
3230 #ifndef _FREEBSD32_SYSPROTO_H_
3231 struct freebsd32_sigqueue_args {
3232 pid_t pid;
3233 int signum;
3234 /* union sigval32 */ int value;
3235 };
3236 #endif
3237 int
3238 freebsd32_sigqueue(struct thread *td, struct freebsd32_sigqueue_args *uap)
3239 {
3240 union sigval sv;
3241
3242 /*
3243 * On 32-bit ABIs, sival_int and sival_ptr are the same.
3244 * On 64-bit little-endian ABIs, the low bits are the same.
3245 * In 64-bit big-endian ABIs, sival_int overlaps with
3246 * sival_ptr's HIGH bits. We choose to support sival_int
3247 * rather than sival_ptr in this case as it seems to be
3248 * more common.
3249 */
3250 bzero(&sv, sizeof(sv));
3251 sv.sival_int = (uint32_t)(uint64_t)uap->value;
3252
3253 return (kern_sigqueue(td, uap->pid, uap->signum, &sv));
3254 }
3255
3256 int
3257 freebsd32_sigtimedwait(struct thread *td, struct freebsd32_sigtimedwait_args *uap)
3258 {
3259 struct timespec32 ts32;
3260 struct timespec ts;
3261 struct timespec *timeout;
3262 sigset_t set;
3263 ksiginfo_t ksi;
3264 struct siginfo32 si32;
3265 int error;
3266
3267 if (uap->timeout) {
3268 error = copyin(uap->timeout, &ts32, sizeof(ts32));
3269 if (error)
3270 return (error);
3271 ts.tv_sec = ts32.tv_sec;
3272 ts.tv_nsec = ts32.tv_nsec;
3273 timeout = &ts;
3274 } else
3275 timeout = NULL;
3276
3277 error = copyin(uap->set, &set, sizeof(set));
3278 if (error)
3279 return (error);
3280
3281 error = kern_sigtimedwait(td, set, &ksi, timeout);
3282 if (error)
3283 return (error);
3284
3285 if (uap->info) {
3286 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
3287 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
3288 }
3289
3290 if (error == 0)
3291 td->td_retval[0] = ksi.ksi_signo;
3292 return (error);
3293 }
3294
3295 /*
3296 * MPSAFE
3297 */
3298 int
3299 freebsd32_sigwaitinfo(struct thread *td, struct freebsd32_sigwaitinfo_args *uap)
3300 {
3301 ksiginfo_t ksi;
3302 struct siginfo32 si32;
3303 sigset_t set;
3304 int error;
3305
3306 error = copyin(uap->set, &set, sizeof(set));
3307 if (error)
3308 return (error);
3309
3310 error = kern_sigtimedwait(td, set, &ksi, NULL);
3311 if (error)
3312 return (error);
3313
3314 if (uap->info) {
3315 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
3316 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
3317 }
3318 if (error == 0)
3319 td->td_retval[0] = ksi.ksi_signo;
3320 return (error);
3321 }
3322
3323 int
3324 freebsd32_cpuset_setid(struct thread *td,
3325 struct freebsd32_cpuset_setid_args *uap)
3326 {
3327
3328 return (kern_cpuset_setid(td, uap->which,
3329 PAIR32TO64(id_t, uap->id), uap->setid));
3330 }
3331
3332 int
3333 freebsd32_cpuset_getid(struct thread *td,
3334 struct freebsd32_cpuset_getid_args *uap)
3335 {
3336
3337 return (kern_cpuset_getid(td, uap->level, uap->which,
3338 PAIR32TO64(id_t, uap->id), uap->setid));
3339 }
3340
3341 static int
3342 copyin32_set(const void *u, void *k, size_t size)
3343 {
3344 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
3345 int rv;
3346 struct bitset *kb = k;
3347 int *p;
3348
3349 rv = copyin(u, k, size);
3350 if (rv != 0)
3351 return (rv);
3352
3353 p = (int *)kb->__bits;
3354 /* Loop through swapping words.
3355 * `size' is in bytes, we need bits. */
3356 for (int i = 0; i < __bitset_words(size * 8); i++) {
3357 int tmp = p[0];
3358 p[0] = p[1];
3359 p[1] = tmp;
3360 p += 2;
3361 }
3362 return (0);
3363 #else
3364 return (copyin(u, k, size));
3365 #endif
3366 }
3367
3368 static int
3369 copyout32_set(const void *k, void *u, size_t size)
3370 {
3371 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
3372 const struct bitset *kb = k;
3373 struct bitset *ub = u;
3374 const int *kp = (const int *)kb->__bits;
3375 int *up = (int *)ub->__bits;
3376 int rv;
3377
3378 for (int i = 0; i < __bitset_words(CPU_SETSIZE); i++) {
3379 /* `size' is in bytes, we need bits. */
3380 for (int i = 0; i < __bitset_words(size * 8); i++) {
3381 rv = suword32(up, kp[1]);
3382 if (rv == 0)
3383 rv = suword32(up + 1, kp[0]);
3384 if (rv != 0)
3385 return (EFAULT);
3386 }
3387 }
3388 return (0);
3389 #else
3390 return (copyout(k, u, size));
3391 #endif
3392 }
3393
3394 static const struct cpuset_copy_cb cpuset_copy32_cb = {
3395 .cpuset_copyin = copyin32_set,
3396 .cpuset_copyout = copyout32_set
3397 };
3398
3399 int
3400 freebsd32_cpuset_getaffinity(struct thread *td,
3401 struct freebsd32_cpuset_getaffinity_args *uap)
3402 {
3403
3404 return (user_cpuset_getaffinity(td, uap->level, uap->which,
3405 PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask,
3406 &cpuset_copy32_cb));
3407 }
3408
3409 int
3410 freebsd32_cpuset_setaffinity(struct thread *td,
3411 struct freebsd32_cpuset_setaffinity_args *uap)
3412 {
3413
3414 return (user_cpuset_setaffinity(td, uap->level, uap->which,
3415 PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask,
3416 &cpuset_copy32_cb));
3417 }
3418
3419 int
3420 freebsd32_cpuset_getdomain(struct thread *td,
3421 struct freebsd32_cpuset_getdomain_args *uap)
3422 {
3423
3424 return (kern_cpuset_getdomain(td, uap->level, uap->which,
3425 PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy,
3426 &cpuset_copy32_cb));
3427 }
3428
3429 int
3430 freebsd32_cpuset_setdomain(struct thread *td,
3431 struct freebsd32_cpuset_setdomain_args *uap)
3432 {
3433
3434 return (kern_cpuset_setdomain(td, uap->level, uap->which,
3435 PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy,
3436 &cpuset_copy32_cb));
3437 }
3438
3439 int
3440 freebsd32_nmount(struct thread *td,
3441 struct freebsd32_nmount_args /* {
3442 struct iovec *iovp;
3443 unsigned int iovcnt;
3444 int flags;
3445 } */ *uap)
3446 {
3447 struct uio *auio;
3448 uint64_t flags;
3449 int error;
3450
3451 /*
3452 * Mount flags are now 64-bits. On 32-bit archtectures only
3453 * 32-bits are passed in, but from here on everything handles
3454 * 64-bit flags correctly.
3455 */
3456 flags = uap->flags;
3457
3458 AUDIT_ARG_FFLAGS(flags);
3459
3460 /*
3461 * Filter out MNT_ROOTFS. We do not want clients of nmount() in
3462 * userspace to set this flag, but we must filter it out if we want
3463 * MNT_UPDATE on the root file system to work.
3464 * MNT_ROOTFS should only be set by the kernel when mounting its
3465 * root file system.
3466 */
3467 flags &= ~MNT_ROOTFS;
3468
3469 /*
3470 * check that we have an even number of iovec's
3471 * and that we have at least two options.
3472 */
3473 if ((uap->iovcnt & 1) || (uap->iovcnt < 4))
3474 return (EINVAL);
3475
3476 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
3477 if (error)
3478 return (error);
3479 error = vfs_donmount(td, flags, auio);
3480
3481 free(auio, M_IOV);
3482 return error;
3483 }
3484
3485 #if 0
3486 int
3487 freebsd32_xxx(struct thread *td, struct freebsd32_xxx_args *uap)
3488 {
3489 struct yyy32 *p32, s32;
3490 struct yyy *p = NULL, s;
3491 struct xxx_arg ap;
3492 int error;
3493
3494 if (uap->zzz) {
3495 error = copyin(uap->zzz, &s32, sizeof(s32));
3496 if (error)
3497 return (error);
3498 /* translate in */
3499 p = &s;
3500 }
3501 error = kern_xxx(td, p);
3502 if (error)
3503 return (error);
3504 if (uap->zzz) {
3505 /* translate out */
3506 error = copyout(&s32, p32, sizeof(s32));
3507 }
3508 return (error);
3509 }
3510 #endif
3511
3512 int
3513 syscall32_module_handler(struct module *mod, int what, void *arg)
3514 {
3515
3516 return (kern_syscall_module_handler(freebsd32_sysent, mod, what, arg));
3517 }
3518
3519 int
3520 syscall32_helper_register(struct syscall_helper_data *sd, int flags)
3521 {
3522
3523 return (kern_syscall_helper_register(freebsd32_sysent, sd, flags));
3524 }
3525
3526 int
3527 syscall32_helper_unregister(struct syscall_helper_data *sd)
3528 {
3529
3530 return (kern_syscall_helper_unregister(freebsd32_sysent, sd));
3531 }
3532
3533 int
3534 freebsd32_copyout_strings(struct image_params *imgp, uintptr_t *stack_base)
3535 {
3536 struct sysentvec *sysent;
3537 int argc, envc, i;
3538 uint32_t *vectp;
3539 char *stringp;
3540 uintptr_t destp, ustringp;
3541 struct freebsd32_ps_strings *arginfo;
3542 char canary[sizeof(long) * 8];
3543 int32_t pagesizes32[MAXPAGESIZES];
3544 size_t execpath_len;
3545 int error, szsigcode;
3546
3547 sysent = imgp->sysent;
3548
3549 arginfo = (struct freebsd32_ps_strings *)PROC_PS_STRINGS(imgp->proc);
3550 imgp->ps_strings = arginfo;
3551 destp = (uintptr_t)arginfo;
3552
3553 /*
3554 * Install sigcode.
3555 */
3556 if (!PROC_HAS_SHP(imgp->proc)) {
3557 szsigcode = *sysent->sv_szsigcode;
3558 destp -= szsigcode;
3559 destp = rounddown2(destp, sizeof(uint32_t));
3560 error = copyout(sysent->sv_sigcode, (void *)destp,
3561 szsigcode);
3562 if (error != 0)
3563 return (error);
3564 }
3565
3566 /*
3567 * Copy the image path for the rtld.
3568 */
3569 if (imgp->execpath != NULL && imgp->auxargs != NULL) {
3570 execpath_len = strlen(imgp->execpath) + 1;
3571 destp -= execpath_len;
3572 imgp->execpathp = (void *)destp;
3573 error = copyout(imgp->execpath, imgp->execpathp, execpath_len);
3574 if (error != 0)
3575 return (error);
3576 }
3577
3578 /*
3579 * Prepare the canary for SSP.
3580 */
3581 arc4rand(canary, sizeof(canary), 0);
3582 destp -= sizeof(canary);
3583 imgp->canary = (void *)destp;
3584 error = copyout(canary, imgp->canary, sizeof(canary));
3585 if (error != 0)
3586 return (error);
3587 imgp->canarylen = sizeof(canary);
3588
3589 /*
3590 * Prepare the pagesizes array.
3591 */
3592 for (i = 0; i < MAXPAGESIZES; i++)
3593 pagesizes32[i] = (uint32_t)pagesizes[i];
3594 destp -= sizeof(pagesizes32);
3595 destp = rounddown2(destp, sizeof(uint32_t));
3596 imgp->pagesizes = (void *)destp;
3597 error = copyout(pagesizes32, imgp->pagesizes, sizeof(pagesizes32));
3598 if (error != 0)
3599 return (error);
3600 imgp->pagesizeslen = sizeof(pagesizes32);
3601
3602 /*
3603 * Allocate room for the argument and environment strings.
3604 */
3605 destp -= ARG_MAX - imgp->args->stringspace;
3606 destp = rounddown2(destp, sizeof(uint32_t));
3607 ustringp = destp;
3608
3609 if (imgp->auxargs) {
3610 /*
3611 * Allocate room on the stack for the ELF auxargs
3612 * array. It has up to AT_COUNT entries.
3613 */
3614 destp -= AT_COUNT * sizeof(Elf32_Auxinfo);
3615 destp = rounddown2(destp, sizeof(uint32_t));
3616 }
3617
3618 vectp = (uint32_t *)destp;
3619
3620 /*
3621 * Allocate room for the argv[] and env vectors including the
3622 * terminating NULL pointers.
3623 */
3624 vectp -= imgp->args->argc + 1 + imgp->args->envc + 1;
3625
3626 /*
3627 * vectp also becomes our initial stack base
3628 */
3629 *stack_base = (uintptr_t)vectp;
3630
3631 stringp = imgp->args->begin_argv;
3632 argc = imgp->args->argc;
3633 envc = imgp->args->envc;
3634 /*
3635 * Copy out strings - arguments and environment.
3636 */
3637 error = copyout(stringp, (void *)ustringp,
3638 ARG_MAX - imgp->args->stringspace);
3639 if (error != 0)
3640 return (error);
3641
3642 /*
3643 * Fill in "ps_strings" struct for ps, w, etc.
3644 */
3645 imgp->argv = vectp;
3646 if (suword32(&arginfo->ps_argvstr, (uint32_t)(intptr_t)vectp) != 0 ||
3647 suword32(&arginfo->ps_nargvstr, argc) != 0)
3648 return (EFAULT);
3649
3650 /*
3651 * Fill in argument portion of vector table.
3652 */
3653 for (; argc > 0; --argc) {
3654 if (suword32(vectp++, ustringp) != 0)
3655 return (EFAULT);
3656 while (*stringp++ != 0)
3657 ustringp++;
3658 ustringp++;
3659 }
3660
3661 /* a null vector table pointer separates the argp's from the envp's */
3662 if (suword32(vectp++, 0) != 0)
3663 return (EFAULT);
3664
3665 imgp->envv = vectp;
3666 if (suword32(&arginfo->ps_envstr, (uint32_t)(intptr_t)vectp) != 0 ||
3667 suword32(&arginfo->ps_nenvstr, envc) != 0)
3668 return (EFAULT);
3669
3670 /*
3671 * Fill in environment portion of vector table.
3672 */
3673 for (; envc > 0; --envc) {
3674 if (suword32(vectp++, ustringp) != 0)
3675 return (EFAULT);
3676 while (*stringp++ != 0)
3677 ustringp++;
3678 ustringp++;
3679 }
3680
3681 /* end of vector table is a null pointer */
3682 if (suword32(vectp, 0) != 0)
3683 return (EFAULT);
3684
3685 if (imgp->auxargs) {
3686 vectp++;
3687 error = imgp->sysent->sv_copyout_auxargs(imgp,
3688 (uintptr_t)vectp);
3689 if (error != 0)
3690 return (error);
3691 }
3692
3693 return (0);
3694 }
3695
3696 int
3697 freebsd32_kldstat(struct thread *td, struct freebsd32_kldstat_args *uap)
3698 {
3699 struct kld_file_stat *stat;
3700 struct kld_file_stat32 *stat32;
3701 int error, version;
3702
3703 if ((error = copyin(&uap->stat->version, &version, sizeof(version)))
3704 != 0)
3705 return (error);
3706 if (version != sizeof(struct kld_file_stat_1_32) &&
3707 version != sizeof(struct kld_file_stat32))
3708 return (EINVAL);
3709
3710 stat = malloc(sizeof(*stat), M_TEMP, M_WAITOK | M_ZERO);
3711 stat32 = malloc(sizeof(*stat32), M_TEMP, M_WAITOK | M_ZERO);
3712 error = kern_kldstat(td, uap->fileid, stat);
3713 if (error == 0) {
3714 bcopy(&stat->name[0], &stat32->name[0], sizeof(stat->name));
3715 CP(*stat, *stat32, refs);
3716 CP(*stat, *stat32, id);
3717 PTROUT_CP(*stat, *stat32, address);
3718 CP(*stat, *stat32, size);
3719 bcopy(&stat->pathname[0], &stat32->pathname[0],
3720 sizeof(stat->pathname));
3721 stat32->version = version;
3722 error = copyout(stat32, uap->stat, version);
3723 }
3724 free(stat, M_TEMP);
3725 free(stat32, M_TEMP);
3726 return (error);
3727 }
3728
3729 int
3730 freebsd32_posix_fallocate(struct thread *td,
3731 struct freebsd32_posix_fallocate_args *uap)
3732 {
3733 int error;
3734
3735 error = kern_posix_fallocate(td, uap->fd,
3736 PAIR32TO64(off_t, uap->offset), PAIR32TO64(off_t, uap->len));
3737 return (kern_posix_error(td, error));
3738 }
3739
3740 int
3741 freebsd32_posix_fadvise(struct thread *td,
3742 struct freebsd32_posix_fadvise_args *uap)
3743 {
3744 int error;
3745
3746 error = kern_posix_fadvise(td, uap->fd, PAIR32TO64(off_t, uap->offset),
3747 PAIR32TO64(off_t, uap->len), uap->advice);
3748 return (kern_posix_error(td, error));
3749 }
3750
3751 int
3752 convert_sigevent32(struct sigevent32 *sig32, struct sigevent *sig)
3753 {
3754
3755 CP(*sig32, *sig, sigev_notify);
3756 switch (sig->sigev_notify) {
3757 case SIGEV_NONE:
3758 break;
3759 case SIGEV_THREAD_ID:
3760 CP(*sig32, *sig, sigev_notify_thread_id);
3761 /* FALLTHROUGH */
3762 case SIGEV_SIGNAL:
3763 CP(*sig32, *sig, sigev_signo);
3764 PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr);
3765 break;
3766 case SIGEV_KEVENT:
3767 CP(*sig32, *sig, sigev_notify_kqueue);
3768 CP(*sig32, *sig, sigev_notify_kevent_flags);
3769 PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr);
3770 break;
3771 default:
3772 return (EINVAL);
3773 }
3774 return (0);
3775 }
3776
3777 int
3778 freebsd32_procctl(struct thread *td, struct freebsd32_procctl_args *uap)
3779 {
3780 void *data;
3781 union {
3782 struct procctl_reaper_status rs;
3783 struct procctl_reaper_pids rp;
3784 struct procctl_reaper_kill rk;
3785 } x;
3786 union {
3787 struct procctl_reaper_pids32 rp;
3788 } x32;
3789 int error, error1, flags, signum;
3790
3791 if (uap->com >= PROC_PROCCTL_MD_MIN)
3792 return (cpu_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
3793 uap->com, PTRIN(uap->data)));
3794
3795 switch (uap->com) {
3796 case PROC_ASLR_CTL:
3797 case PROC_PROTMAX_CTL:
3798 case PROC_SPROTECT:
3799 case PROC_STACKGAP_CTL:
3800 case PROC_TRACE_CTL:
3801 case PROC_TRAPCAP_CTL:
3802 case PROC_NO_NEW_PRIVS_CTL:
3803 case PROC_WXMAP_CTL:
3804 error = copyin(PTRIN(uap->data), &flags, sizeof(flags));
3805 if (error != 0)
3806 return (error);
3807 data = &flags;
3808 break;
3809 case PROC_REAP_ACQUIRE:
3810 case PROC_REAP_RELEASE:
3811 if (uap->data != NULL)
3812 return (EINVAL);
3813 data = NULL;
3814 break;
3815 case PROC_REAP_STATUS:
3816 data = &x.rs;
3817 break;
3818 case PROC_REAP_GETPIDS:
3819 error = copyin(uap->data, &x32.rp, sizeof(x32.rp));
3820 if (error != 0)
3821 return (error);
3822 CP(x32.rp, x.rp, rp_count);
3823 PTRIN_CP(x32.rp, x.rp, rp_pids);
3824 data = &x.rp;
3825 break;
3826 case PROC_REAP_KILL:
3827 error = copyin(uap->data, &x.rk, sizeof(x.rk));
3828 if (error != 0)
3829 return (error);
3830 data = &x.rk;
3831 break;
3832 case PROC_ASLR_STATUS:
3833 case PROC_PROTMAX_STATUS:
3834 case PROC_STACKGAP_STATUS:
3835 case PROC_TRACE_STATUS:
3836 case PROC_TRAPCAP_STATUS:
3837 case PROC_NO_NEW_PRIVS_STATUS:
3838 case PROC_WXMAP_STATUS:
3839 data = &flags;
3840 break;
3841 case PROC_PDEATHSIG_CTL:
3842 error = copyin(uap->data, &signum, sizeof(signum));
3843 if (error != 0)
3844 return (error);
3845 data = &signum;
3846 break;
3847 case PROC_PDEATHSIG_STATUS:
3848 data = &signum;
3849 break;
3850 default:
3851 return (EINVAL);
3852 }
3853 error = kern_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
3854 uap->com, data);
3855 switch (uap->com) {
3856 case PROC_REAP_STATUS:
3857 if (error == 0)
3858 error = copyout(&x.rs, uap->data, sizeof(x.rs));
3859 break;
3860 case PROC_REAP_KILL:
3861 error1 = copyout(&x.rk, uap->data, sizeof(x.rk));
3862 if (error == 0)
3863 error = error1;
3864 break;
3865 case PROC_ASLR_STATUS:
3866 case PROC_PROTMAX_STATUS:
3867 case PROC_STACKGAP_STATUS:
3868 case PROC_TRACE_STATUS:
3869 case PROC_TRAPCAP_STATUS:
3870 case PROC_NO_NEW_PRIVS_STATUS:
3871 case PROC_WXMAP_STATUS:
3872 if (error == 0)
3873 error = copyout(&flags, uap->data, sizeof(flags));
3874 break;
3875 case PROC_PDEATHSIG_STATUS:
3876 if (error == 0)
3877 error = copyout(&signum, uap->data, sizeof(signum));
3878 break;
3879 }
3880 return (error);
3881 }
3882
3883 int
3884 freebsd32_fcntl(struct thread *td, struct freebsd32_fcntl_args *uap)
3885 {
3886 long tmp;
3887
3888 switch (uap->cmd) {
3889 /*
3890 * Do unsigned conversion for arg when operation
3891 * interprets it as flags or pointer.
3892 */
3893 case F_SETLK_REMOTE:
3894 case F_SETLKW:
3895 case F_SETLK:
3896 case F_GETLK:
3897 case F_SETFD:
3898 case F_SETFL:
3899 case F_OGETLK:
3900 case F_OSETLK:
3901 case F_OSETLKW:
3902 case F_KINFO:
3903 tmp = (unsigned int)(uap->arg);
3904 break;
3905 default:
3906 tmp = uap->arg;
3907 break;
3908 }
3909 return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, tmp));
3910 }
3911
3912 int
3913 freebsd32_ppoll(struct thread *td, struct freebsd32_ppoll_args *uap)
3914 {
3915 struct timespec32 ts32;
3916 struct timespec ts, *tsp;
3917 sigset_t set, *ssp;
3918 int error;
3919
3920 if (uap->ts != NULL) {
3921 error = copyin(uap->ts, &ts32, sizeof(ts32));
3922 if (error != 0)
3923 return (error);
3924 CP(ts32, ts, tv_sec);
3925 CP(ts32, ts, tv_nsec);
3926 tsp = &ts;
3927 } else
3928 tsp = NULL;
3929 if (uap->set != NULL) {
3930 error = copyin(uap->set, &set, sizeof(set));
3931 if (error != 0)
3932 return (error);
3933 ssp = &set;
3934 } else
3935 ssp = NULL;
3936
3937 return (kern_poll(td, uap->fds, uap->nfds, tsp, ssp));
3938 }
3939
3940 int
3941 freebsd32_sched_rr_get_interval(struct thread *td,
3942 struct freebsd32_sched_rr_get_interval_args *uap)
3943 {
3944 struct timespec ts;
3945 struct timespec32 ts32;
3946 int error;
3947
3948 error = kern_sched_rr_get_interval(td, uap->pid, &ts);
3949 if (error == 0) {
3950 CP(ts, ts32, tv_sec);
3951 CP(ts, ts32, tv_nsec);
3952 error = copyout(&ts32, uap->interval, sizeof(ts32));
3953 }
3954 return (error);
3955 }
3956
3957 static void
3958 timex_to_32(struct timex32 *dst, struct timex *src)
3959 {
3960 CP(*src, *dst, modes);
3961 CP(*src, *dst, offset);
3962 CP(*src, *dst, freq);
3963 CP(*src, *dst, maxerror);
3964 CP(*src, *dst, esterror);
3965 CP(*src, *dst, status);
3966 CP(*src, *dst, constant);
3967 CP(*src, *dst, precision);
3968 CP(*src, *dst, tolerance);
3969 CP(*src, *dst, ppsfreq);
3970 CP(*src, *dst, jitter);
3971 CP(*src, *dst, shift);
3972 CP(*src, *dst, stabil);
3973 CP(*src, *dst, jitcnt);
3974 CP(*src, *dst, calcnt);
3975 CP(*src, *dst, errcnt);
3976 CP(*src, *dst, stbcnt);
3977 }
3978
3979 static void
3980 timex_from_32(struct timex *dst, struct timex32 *src)
3981 {
3982 CP(*src, *dst, modes);
3983 CP(*src, *dst, offset);
3984 CP(*src, *dst, freq);
3985 CP(*src, *dst, maxerror);
3986 CP(*src, *dst, esterror);
3987 CP(*src, *dst, status);
3988 CP(*src, *dst, constant);
3989 CP(*src, *dst, precision);
3990 CP(*src, *dst, tolerance);
3991 CP(*src, *dst, ppsfreq);
3992 CP(*src, *dst, jitter);
3993 CP(*src, *dst, shift);
3994 CP(*src, *dst, stabil);
3995 CP(*src, *dst, jitcnt);
3996 CP(*src, *dst, calcnt);
3997 CP(*src, *dst, errcnt);
3998 CP(*src, *dst, stbcnt);
3999 }
4000
4001 int
4002 freebsd32_ntp_adjtime(struct thread *td, struct freebsd32_ntp_adjtime_args *uap)
4003 {
4004 struct timex tx;
4005 struct timex32 tx32;
4006 int error, retval;
4007
4008 error = copyin(uap->tp, &tx32, sizeof(tx32));
4009 if (error == 0) {
4010 timex_from_32(&tx, &tx32);
4011 error = kern_ntp_adjtime(td, &tx, &retval);
4012 if (error == 0) {
4013 timex_to_32(&tx32, &tx);
4014 error = copyout(&tx32, uap->tp, sizeof(tx32));
4015 if (error == 0)
4016 td->td_retval[0] = retval;
4017 }
4018 }
4019 return (error);
4020 }
4021
4022 #ifdef FFCLOCK
4023 extern struct mtx ffclock_mtx;
4024 extern struct ffclock_estimate ffclock_estimate;
4025 extern int8_t ffclock_updated;
4026
4027 int
4028 freebsd32_ffclock_setestimate(struct thread *td,
4029 struct freebsd32_ffclock_setestimate_args *uap)
4030 {
4031 struct ffclock_estimate cest;
4032 struct ffclock_estimate32 cest32;
4033 int error;
4034
4035 /* Reuse of PRIV_CLOCK_SETTIME. */
4036 if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0)
4037 return (error);
4038
4039 if ((error = copyin(uap->cest, &cest32,
4040 sizeof(struct ffclock_estimate32))) != 0)
4041 return (error);
4042
4043 CP(cest.update_time, cest32.update_time, sec);
4044 memcpy(&cest.update_time.frac, &cest32.update_time.frac, sizeof(uint64_t));
4045 CP(cest, cest32, update_ffcount);
4046 CP(cest, cest32, leapsec_next);
4047 CP(cest, cest32, period);
4048 CP(cest, cest32, errb_abs);
4049 CP(cest, cest32, errb_rate);
4050 CP(cest, cest32, status);
4051 CP(cest, cest32, leapsec_total);
4052 CP(cest, cest32, leapsec);
4053
4054 mtx_lock(&ffclock_mtx);
4055 memcpy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
4056 ffclock_updated++;
4057 mtx_unlock(&ffclock_mtx);
4058 return (error);
4059 }
4060
4061 int
4062 freebsd32_ffclock_getestimate(struct thread *td,
4063 struct freebsd32_ffclock_getestimate_args *uap)
4064 {
4065 struct ffclock_estimate cest;
4066 struct ffclock_estimate32 cest32;
4067 int error;
4068
4069 mtx_lock(&ffclock_mtx);
4070 memcpy(&cest, &ffclock_estimate, sizeof(struct ffclock_estimate));
4071 mtx_unlock(&ffclock_mtx);
4072
4073 CP(cest32.update_time, cest.update_time, sec);
4074 memcpy(&cest32.update_time.frac, &cest.update_time.frac, sizeof(uint64_t));
4075 CP(cest32, cest, update_ffcount);
4076 CP(cest32, cest, leapsec_next);
4077 CP(cest32, cest, period);
4078 CP(cest32, cest, errb_abs);
4079 CP(cest32, cest, errb_rate);
4080 CP(cest32, cest, status);
4081 CP(cest32, cest, leapsec_total);
4082 CP(cest32, cest, leapsec);
4083
4084 error = copyout(&cest32, uap->cest, sizeof(struct ffclock_estimate32));
4085 return (error);
4086 }
4087 #else /* !FFCLOCK */
4088 int
4089 freebsd32_ffclock_setestimate(struct thread *td,
4090 struct freebsd32_ffclock_setestimate_args *uap)
4091 {
4092 return (ENOSYS);
4093 }
4094
4095 int
4096 freebsd32_ffclock_getestimate(struct thread *td,
4097 struct freebsd32_ffclock_getestimate_args *uap)
4098 {
4099 return (ENOSYS);
4100 }
4101 #endif /* FFCLOCK */
4102
4103 #ifdef COMPAT_43
4104 int
4105 ofreebsd32_sethostid(struct thread *td, struct ofreebsd32_sethostid_args *uap)
4106 {
4107 int name[] = { CTL_KERN, KERN_HOSTID };
4108 long hostid;
4109
4110 hostid = uap->hostid;
4111 return (kernel_sysctl(td, name, nitems(name), NULL, NULL, &hostid,
4112 sizeof(hostid), NULL, 0));
4113 }
4114 #endif
Cache object: f0956ad6b854507e2d691d14322bd6d5
|