linux32_machdep.c revision 144449
1133819Stjr/*- 2133819Stjr * Copyright (c) 2004 Tim J. Robbins 3133819Stjr * Copyright (c) 2002 Doug Rabson 4133819Stjr * Copyright (c) 2000 Marcel Moolenaar 5133819Stjr * All rights reserved. 6133819Stjr * 7133819Stjr * Redistribution and use in source and binary forms, with or without 8133819Stjr * modification, are permitted provided that the following conditions 9133819Stjr * are met: 10133819Stjr * 1. Redistributions of source code must retain the above copyright 11133819Stjr * notice, this list of conditions and the following disclaimer 12133819Stjr * in this position and unchanged. 13133819Stjr * 2. Redistributions in binary form must reproduce the above copyright 14133819Stjr * notice, this list of conditions and the following disclaimer in the 15133819Stjr * documentation and/or other materials provided with the distribution. 16133819Stjr * 3. The name of the author may not be used to endorse or promote products 17133819Stjr * derived from this software without specific prior written permission. 18133819Stjr * 19133819Stjr * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20133819Stjr * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21133819Stjr * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22133819Stjr * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23133819Stjr * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24133819Stjr * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25133819Stjr * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26133819Stjr * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27133819Stjr * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28133819Stjr * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29133819Stjr */ 30133819Stjr 31133819Stjr#include <sys/cdefs.h> 32133819Stjr__FBSDID("$FreeBSD: head/sys/amd64/linux32/linux32_machdep.c 144449 2005-03-31 22:57:21Z jhb $"); 33133819Stjr 34133819Stjr#include <sys/param.h> 35133819Stjr#include <sys/kernel.h> 36133819Stjr#include <sys/systm.h> 37142057Sjhb#include <sys/imgact.h> 38133819Stjr#include <sys/lock.h> 39133819Stjr#include <sys/malloc.h> 40133819Stjr#include <sys/mman.h> 41133819Stjr#include <sys/mutex.h> 42133819Stjr#include <sys/proc.h> 43133819Stjr#include <sys/resource.h> 44133819Stjr#include <sys/resourcevar.h> 45133819Stjr#include <sys/syscallsubr.h> 46133819Stjr#include <sys/sysproto.h> 47133819Stjr#include <sys/unistd.h> 48133819Stjr 49133819Stjr#include <machine/frame.h> 50133819Stjr 51133819Stjr#include <vm/vm.h> 52133819Stjr#include <vm/pmap.h> 53142057Sjhb#include <vm/vm_extern.h> 54142057Sjhb#include <vm/vm_kern.h> 55133819Stjr#include <vm/vm_map.h> 56133819Stjr 57133819Stjr#include <amd64/linux32/linux.h> 58133819Stjr#include <amd64/linux32/linux32_proto.h> 59133819Stjr#include <compat/linux/linux_ipc.h> 60133819Stjr#include <compat/linux/linux_signal.h> 61133819Stjr#include <compat/linux/linux_util.h> 62133819Stjr 63133819Stjrstruct l_old_select_argv { 64133819Stjr l_int nfds; 65133819Stjr l_uintptr_t readfds; 66133819Stjr l_uintptr_t writefds; 67133819Stjr l_uintptr_t exceptfds; 68133819Stjr l_uintptr_t timeout; 69133819Stjr} __packed; 70133819Stjr 71133819Stjrint 72133819Stjrlinux_to_bsd_sigaltstack(int lsa) 73133819Stjr{ 74133819Stjr int bsa = 0; 75133819Stjr 76133819Stjr if (lsa & LINUX_SS_DISABLE) 77133819Stjr bsa |= SS_DISABLE; 78133819Stjr if (lsa & LINUX_SS_ONSTACK) 79133819Stjr bsa |= SS_ONSTACK; 80133819Stjr return (bsa); 81133819Stjr} 82133819Stjr 83133819Stjrint 84133819Stjrbsd_to_linux_sigaltstack(int bsa) 85133819Stjr{ 86133819Stjr int lsa = 0; 87133819Stjr 88133819Stjr if (bsa & SS_DISABLE) 89133819Stjr lsa |= LINUX_SS_DISABLE; 90133819Stjr if (bsa & SS_ONSTACK) 91133819Stjr lsa |= LINUX_SS_ONSTACK; 92133819Stjr return (lsa); 93133819Stjr} 94133819Stjr 95142057Sjhb/* 96142057Sjhb * Custom version of exec_copyin_args() so that we can translate 97142057Sjhb * the pointers. 98142057Sjhb */ 99142057Sjhbstatic int 100142057Sjhblinux_exec_copyin_args(struct image_args *args, char *fname, 101142057Sjhb enum uio_seg segflg, char **argv, char **envv) 102133819Stjr{ 103142057Sjhb char *argp, *envp; 104142057Sjhb u_int32_t *p32, arg; 105142057Sjhb size_t length; 106133819Stjr int error; 107133819Stjr 108142057Sjhb bzero(args, sizeof(*args)); 109142057Sjhb if (argv == NULL) 110142057Sjhb return (EFAULT); 111133819Stjr 112142057Sjhb /* 113142057Sjhb * Allocate temporary demand zeroed space for argument and 114142057Sjhb * environment strings 115142057Sjhb */ 116142057Sjhb args->buf = (char *) kmem_alloc_wait(exec_map, PATH_MAX + ARG_MAX); 117142057Sjhb if (args->buf == NULL) 118142057Sjhb return (ENOMEM); 119142057Sjhb args->begin_argv = args->buf; 120142057Sjhb args->endp = args->begin_argv; 121142057Sjhb args->stringspace = ARG_MAX; 122133819Stjr 123142057Sjhb args->fname = args->buf + ARG_MAX; 124133819Stjr 125142057Sjhb /* 126142057Sjhb * Copy the file name. 127142057Sjhb */ 128142057Sjhb error = (segflg == UIO_SYSSPACE) ? 129142057Sjhb copystr(fname, args->fname, PATH_MAX, &length) : 130142057Sjhb copyinstr(fname, args->fname, PATH_MAX, &length); 131142057Sjhb if (error != 0) 132142057Sjhb return (error); 133142057Sjhb 134142057Sjhb /* 135142057Sjhb * extract arguments first 136142057Sjhb */ 137142057Sjhb p32 = (u_int32_t *)argv; 138142057Sjhb for (;;) { 139142057Sjhb error = copyin(p32++, &arg, sizeof(arg)); 140142057Sjhb if (error) 141142057Sjhb return (error); 142142057Sjhb if (arg == 0) 143142057Sjhb break; 144142057Sjhb argp = PTRIN(arg); 145142057Sjhb error = copyinstr(argp, args->endp, args->stringspace, &length); 146142057Sjhb if (error) { 147142057Sjhb if (error == ENAMETOOLONG) 148142057Sjhb return (E2BIG); 149142057Sjhb else 150142057Sjhb return (error); 151142057Sjhb } 152142057Sjhb args->stringspace -= length; 153142057Sjhb args->endp += length; 154142057Sjhb args->argc++; 155133819Stjr } 156142057Sjhb 157142057Sjhb args->begin_envv = args->endp; 158142057Sjhb 159142057Sjhb /* 160142057Sjhb * extract environment strings 161142057Sjhb */ 162142057Sjhb if (envv) { 163142057Sjhb p32 = (u_int32_t *)envv; 164142057Sjhb for (;;) { 165133819Stjr error = copyin(p32++, &arg, sizeof(arg)); 166133819Stjr if (error) 167142057Sjhb return (error); 168142057Sjhb if (arg == 0) 169142057Sjhb break; 170142057Sjhb envp = PTRIN(arg); 171142057Sjhb error = copyinstr(envp, args->endp, args->stringspace, 172142057Sjhb &length); 173142057Sjhb if (error) { 174142057Sjhb if (error == ENAMETOOLONG) 175142057Sjhb return (E2BIG); 176142057Sjhb else 177142057Sjhb return (error); 178142057Sjhb } 179142057Sjhb args->stringspace -= length; 180142057Sjhb args->endp += length; 181142057Sjhb args->envc++; 182142057Sjhb } 183133819Stjr } 184133819Stjr 185142057Sjhb return (0); 186133819Stjr} 187133819Stjr 188142057Sjhbint 189142057Sjhblinux_execve(struct thread *td, struct linux_execve_args *args) 190142057Sjhb{ 191142057Sjhb struct image_args eargs; 192142057Sjhb char *path; 193142057Sjhb int error; 194142057Sjhb 195142057Sjhb LCONVPATHEXIST(td, args->path, &path); 196142057Sjhb 197142057Sjhb#ifdef DEBUG 198142057Sjhb if (ldebug(execve)) 199142057Sjhb printf(ARGS(execve, "%s"), path); 200142057Sjhb#endif 201142057Sjhb 202142057Sjhb error = linux_exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp, 203142057Sjhb args->envp); 204142057Sjhb free(path, M_TEMP); 205142057Sjhb if (error == 0) 206142057Sjhb error = kern_execve(td, &eargs, NULL); 207142057Sjhb exec_free_args(&eargs); 208142057Sjhb return (error); 209142057Sjhb} 210142057Sjhb 211133819Stjrstruct iovec32 { 212133819Stjr u_int32_t iov_base; 213133819Stjr int iov_len; 214133819Stjr}; 215133819Stjr 216133819StjrCTASSERT(sizeof(struct iovec32) == 8); 217133819Stjr 218144449Sjhbstatic int 219144449Sjhblinux32_copyinuio(struct iovec32 *iovp, u_int iovcnt, struct uio **uiop) 220133819Stjr{ 221144449Sjhb struct iovec32 iov32; 222144449Sjhb struct iovec *iov; 223144449Sjhb struct uio *uio; 224144449Sjhb u_int iovlen; 225144449Sjhb int error, i; 226133819Stjr 227144449Sjhb *uiop = NULL; 228144449Sjhb if (iovcnt > UIO_MAXIOV) 229133819Stjr return (EINVAL); 230144449Sjhb iovlen = iovcnt * sizeof(struct iovec); 231144449Sjhb uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK); 232144449Sjhb iov = (struct iovec *)(uio + 1); 233144449Sjhb for (i = 0; i < iovcnt; i++) { 234144449Sjhb error = copyin(&iovp[i], &iov32, sizeof(struct iovec32)); 235144449Sjhb if (error) { 236144449Sjhb free(uio, M_IOV); 237144449Sjhb return (error); 238144449Sjhb } 239144449Sjhb iov[i].iov_base = PTRIN(iov32.iov_base); 240144449Sjhb iov[i].iov_len = iov32.iov_len; 241133819Stjr } 242144449Sjhb uio->uio_iov = iov; 243144449Sjhb uio->uio_iovcnt = iovcnt; 244144449Sjhb uio->uio_segflg = UIO_USERSPACE; 245144449Sjhb uio->uio_offset = -1; 246144449Sjhb uio->uio_resid = 0; 247144449Sjhb for (i = 0; i < iovcnt; i++) { 248144449Sjhb if (iov->iov_len > INT_MAX - uio->uio_resid) { 249144449Sjhb free(uio, M_IOV); 250144449Sjhb return (EINVAL); 251144449Sjhb } 252144449Sjhb uio->uio_resid += iov->iov_len; 253144449Sjhb iov++; 254144449Sjhb } 255144449Sjhb *uiop = uio; 256144449Sjhb return (0); 257144449Sjhb} 258133819Stjr 259144449Sjhbint 260144449Sjhblinux_readv(struct thread *td, struct linux_readv_args *uap) 261144449Sjhb{ 262144449Sjhb struct uio *auio; 263144449Sjhb int error; 264133819Stjr 265144449Sjhb error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); 266144449Sjhb if (error) 267144449Sjhb return (error); 268144449Sjhb error = kern_readv(td, uap->fd, auio); 269144449Sjhb free(auio, M_IOV); 270133819Stjr return (error); 271133819Stjr} 272133819Stjr 273133819Stjrint 274133819Stjrlinux_writev(struct thread *td, struct linux_writev_args *uap) 275133819Stjr{ 276144449Sjhb struct uio *auio; 277144449Sjhb int error; 278133819Stjr 279144449Sjhb error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); 280144449Sjhb if (error) 281144449Sjhb return (error); 282144449Sjhb error = kern_writev(td, uap->fd, auio); 283144449Sjhb free(auio, M_IOV); 284133819Stjr return (error); 285133819Stjr} 286133819Stjr 287133819Stjrstruct l_ipc_kludge { 288133819Stjr l_uintptr_t msgp; 289133819Stjr l_long msgtyp; 290133819Stjr} __packed; 291133819Stjr 292133819Stjrint 293133819Stjrlinux_ipc(struct thread *td, struct linux_ipc_args *args) 294133819Stjr{ 295133819Stjr 296133819Stjr switch (args->what & 0xFFFF) { 297133819Stjr case LINUX_SEMOP: { 298133819Stjr struct linux_semop_args a; 299133819Stjr 300133819Stjr a.semid = args->arg1; 301133819Stjr a.tsops = args->ptr; 302133819Stjr a.nsops = args->arg2; 303133819Stjr return (linux_semop(td, &a)); 304133819Stjr } 305133819Stjr case LINUX_SEMGET: { 306133819Stjr struct linux_semget_args a; 307133819Stjr 308133819Stjr a.key = args->arg1; 309133819Stjr a.nsems = args->arg2; 310133819Stjr a.semflg = args->arg3; 311133819Stjr return (linux_semget(td, &a)); 312133819Stjr } 313133819Stjr case LINUX_SEMCTL: { 314133819Stjr struct linux_semctl_args a; 315133819Stjr int error; 316133819Stjr 317133819Stjr a.semid = args->arg1; 318133819Stjr a.semnum = args->arg2; 319133819Stjr a.cmd = args->arg3; 320133819Stjr error = copyin(args->ptr, &a.arg, sizeof(a.arg)); 321133819Stjr if (error) 322133819Stjr return (error); 323133819Stjr return (linux_semctl(td, &a)); 324133819Stjr } 325133819Stjr case LINUX_MSGSND: { 326133819Stjr struct linux_msgsnd_args a; 327133819Stjr 328133819Stjr a.msqid = args->arg1; 329133819Stjr a.msgp = args->ptr; 330133819Stjr a.msgsz = args->arg2; 331133819Stjr a.msgflg = args->arg3; 332133819Stjr return (linux_msgsnd(td, &a)); 333133819Stjr } 334133819Stjr case LINUX_MSGRCV: { 335133819Stjr struct linux_msgrcv_args a; 336133819Stjr 337133819Stjr a.msqid = args->arg1; 338133819Stjr a.msgsz = args->arg2; 339133819Stjr a.msgflg = args->arg3; 340133819Stjr if ((args->what >> 16) == 0) { 341133819Stjr struct l_ipc_kludge tmp; 342133819Stjr int error; 343133819Stjr 344133819Stjr if (args->ptr == 0) 345133819Stjr return (EINVAL); 346133819Stjr error = copyin(args->ptr, &tmp, sizeof(tmp)); 347133819Stjr if (error) 348133819Stjr return (error); 349133819Stjr a.msgp = PTRIN(tmp.msgp); 350133819Stjr a.msgtyp = tmp.msgtyp; 351133819Stjr } else { 352133819Stjr a.msgp = args->ptr; 353133819Stjr a.msgtyp = args->arg5; 354133819Stjr } 355133819Stjr return (linux_msgrcv(td, &a)); 356133819Stjr } 357133819Stjr case LINUX_MSGGET: { 358133819Stjr struct linux_msgget_args a; 359133819Stjr 360133819Stjr a.key = args->arg1; 361133819Stjr a.msgflg = args->arg2; 362133819Stjr return (linux_msgget(td, &a)); 363133819Stjr } 364133819Stjr case LINUX_MSGCTL: { 365133819Stjr struct linux_msgctl_args a; 366133819Stjr 367133819Stjr a.msqid = args->arg1; 368133819Stjr a.cmd = args->arg2; 369133819Stjr a.buf = args->ptr; 370133819Stjr return (linux_msgctl(td, &a)); 371133819Stjr } 372133819Stjr case LINUX_SHMAT: { 373133819Stjr struct linux_shmat_args a; 374133819Stjr 375133819Stjr a.shmid = args->arg1; 376133819Stjr a.shmaddr = args->ptr; 377133819Stjr a.shmflg = args->arg2; 378144441Sjhb a.raddr = PTRIN((l_uint)args->arg3); 379133819Stjr return (linux_shmat(td, &a)); 380133819Stjr } 381133819Stjr case LINUX_SHMDT: { 382133819Stjr struct linux_shmdt_args a; 383133819Stjr 384133819Stjr a.shmaddr = args->ptr; 385133819Stjr return (linux_shmdt(td, &a)); 386133819Stjr } 387133819Stjr case LINUX_SHMGET: { 388133819Stjr struct linux_shmget_args a; 389133819Stjr 390133819Stjr a.key = args->arg1; 391133819Stjr a.size = args->arg2; 392133819Stjr a.shmflg = args->arg3; 393133819Stjr return (linux_shmget(td, &a)); 394133819Stjr } 395133819Stjr case LINUX_SHMCTL: { 396133819Stjr struct linux_shmctl_args a; 397133819Stjr 398133819Stjr a.shmid = args->arg1; 399133819Stjr a.cmd = args->arg2; 400133819Stjr a.buf = args->ptr; 401133819Stjr return (linux_shmctl(td, &a)); 402133819Stjr } 403133819Stjr default: 404133819Stjr break; 405133819Stjr } 406133819Stjr 407133819Stjr return (EINVAL); 408133819Stjr} 409133819Stjr 410133819Stjrint 411133819Stjrlinux_old_select(struct thread *td, struct linux_old_select_args *args) 412133819Stjr{ 413133819Stjr struct l_old_select_argv linux_args; 414133819Stjr struct linux_select_args newsel; 415133819Stjr int error; 416133819Stjr 417133819Stjr#ifdef DEBUG 418133819Stjr if (ldebug(old_select)) 419133819Stjr printf(ARGS(old_select, "%p"), args->ptr); 420133819Stjr#endif 421133819Stjr 422133819Stjr error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 423133819Stjr if (error) 424133819Stjr return (error); 425133819Stjr 426133819Stjr newsel.nfds = linux_args.nfds; 427133819Stjr newsel.readfds = PTRIN(linux_args.readfds); 428133819Stjr newsel.writefds = PTRIN(linux_args.writefds); 429133819Stjr newsel.exceptfds = PTRIN(linux_args.exceptfds); 430133819Stjr newsel.timeout = PTRIN(linux_args.timeout); 431133819Stjr return (linux_select(td, &newsel)); 432133819Stjr} 433133819Stjr 434133819Stjrint 435133819Stjrlinux_fork(struct thread *td, struct linux_fork_args *args) 436133819Stjr{ 437133819Stjr int error; 438133819Stjr 439133819Stjr#ifdef DEBUG 440133819Stjr if (ldebug(fork)) 441133819Stjr printf(ARGS(fork, "")); 442133819Stjr#endif 443133819Stjr 444133819Stjr if ((error = fork(td, (struct fork_args *)args)) != 0) 445133819Stjr return (error); 446133819Stjr 447133819Stjr if (td->td_retval[1] == 1) 448133819Stjr td->td_retval[0] = 0; 449133819Stjr return (0); 450133819Stjr} 451133819Stjr 452133819Stjrint 453133819Stjrlinux_vfork(struct thread *td, struct linux_vfork_args *args) 454133819Stjr{ 455133819Stjr int error; 456133819Stjr 457133819Stjr#ifdef DEBUG 458133819Stjr if (ldebug(vfork)) 459133819Stjr printf(ARGS(vfork, "")); 460133819Stjr#endif 461133819Stjr 462133819Stjr if ((error = vfork(td, (struct vfork_args *)args)) != 0) 463133819Stjr return (error); 464133819Stjr /* Are we the child? */ 465133819Stjr if (td->td_retval[1] == 1) 466133819Stjr td->td_retval[0] = 0; 467133819Stjr return (0); 468133819Stjr} 469133819Stjr 470133819Stjr#define CLONE_VM 0x100 471133819Stjr#define CLONE_FS 0x200 472133819Stjr#define CLONE_FILES 0x400 473133819Stjr#define CLONE_SIGHAND 0x800 474133819Stjr#define CLONE_PID 0x1000 475133819Stjr 476133819Stjrint 477133819Stjrlinux_clone(struct thread *td, struct linux_clone_args *args) 478133819Stjr{ 479133819Stjr int error, ff = RFPROC | RFSTOPPED; 480133819Stjr struct proc *p2; 481133819Stjr struct thread *td2; 482133819Stjr int exit_signal; 483133819Stjr 484133819Stjr#ifdef DEBUG 485133819Stjr if (ldebug(clone)) { 486133819Stjr printf(ARGS(clone, "flags %x, stack %x"), 487133843Sobrien (unsigned int)(uintptr_t)args->flags, 488133843Sobrien (unsigned int)(uintptr_t)args->stack); 489133819Stjr if (args->flags & CLONE_PID) 490133819Stjr printf(LMSG("CLONE_PID not yet supported")); 491133819Stjr } 492133819Stjr#endif 493133819Stjr 494133819Stjr if (!args->stack) 495133819Stjr return (EINVAL); 496133819Stjr 497133819Stjr exit_signal = args->flags & 0x000000ff; 498133819Stjr if (exit_signal >= LINUX_NSIG) 499133819Stjr return (EINVAL); 500133819Stjr 501133819Stjr if (exit_signal <= LINUX_SIGTBLSZ) 502133819Stjr exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)]; 503133819Stjr 504133819Stjr if (args->flags & CLONE_VM) 505133819Stjr ff |= RFMEM; 506133819Stjr if (args->flags & CLONE_SIGHAND) 507133819Stjr ff |= RFSIGSHARE; 508133819Stjr if (!(args->flags & CLONE_FILES)) 509133819Stjr ff |= RFFDG; 510133819Stjr 511133819Stjr error = fork1(td, ff, 0, &p2); 512133819Stjr if (error) 513133819Stjr return (error); 514133819Stjr 515133819Stjr 516133819Stjr PROC_LOCK(p2); 517133819Stjr p2->p_sigparent = exit_signal; 518133819Stjr PROC_UNLOCK(p2); 519133819Stjr td2 = FIRST_THREAD_IN_PROC(p2); 520133819Stjr td2->td_frame->tf_rsp = PTROUT(args->stack); 521133819Stjr 522133819Stjr#ifdef DEBUG 523133819Stjr if (ldebug(clone)) 524133819Stjr printf(LMSG("clone: successful rfork to %ld, stack %p sig = %d"), 525133819Stjr (long)p2->p_pid, args->stack, exit_signal); 526133819Stjr#endif 527133819Stjr 528133819Stjr /* 529133819Stjr * Make this runnable after we are finished with it. 530133819Stjr */ 531133819Stjr mtx_lock_spin(&sched_lock); 532133819Stjr TD_SET_CAN_RUN(td2); 533134586Sjulian setrunqueue(td2, SRQ_BORING); 534133819Stjr mtx_unlock_spin(&sched_lock); 535133819Stjr 536133819Stjr td->td_retval[0] = p2->p_pid; 537133819Stjr td->td_retval[1] = 0; 538133819Stjr return (0); 539133819Stjr} 540133819Stjr 541133819Stjr/* XXX move */ 542133819Stjrstruct l_mmap_argv { 543133819Stjr l_ulong addr; 544144441Sjhb l_ulong len; 545144441Sjhb l_ulong prot; 546144441Sjhb l_ulong flags; 547144441Sjhb l_ulong fd; 548144441Sjhb l_ulong pgoff; 549133819Stjr}; 550133819Stjr 551133819Stjr#define STACK_SIZE (2 * 1024 * 1024) 552133819Stjr#define GUARD_SIZE (4 * PAGE_SIZE) 553133819Stjr 554133819Stjrstatic int linux_mmap_common(struct thread *, struct l_mmap_argv *); 555133819Stjr 556133819Stjrint 557133819Stjrlinux_mmap2(struct thread *td, struct linux_mmap2_args *args) 558133819Stjr{ 559133819Stjr struct l_mmap_argv linux_args; 560133819Stjr 561133819Stjr#ifdef DEBUG 562133819Stjr if (ldebug(mmap2)) 563133819Stjr printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"), 564133843Sobrien (void *)(intptr_t)args->addr, args->len, args->prot, 565133819Stjr args->flags, args->fd, args->pgoff); 566133819Stjr#endif 567133819Stjr 568133819Stjr linux_args.addr = PTROUT(args->addr); 569133819Stjr linux_args.len = args->len; 570133819Stjr linux_args.prot = args->prot; 571133819Stjr linux_args.flags = args->flags; 572133819Stjr linux_args.fd = args->fd; 573144441Sjhb linux_args.pgoff = args->pgoff; 574133819Stjr 575133819Stjr return (linux_mmap_common(td, &linux_args)); 576133819Stjr} 577133819Stjr 578133819Stjrint 579133819Stjrlinux_mmap(struct thread *td, struct linux_mmap_args *args) 580133819Stjr{ 581133819Stjr int error; 582133819Stjr struct l_mmap_argv linux_args; 583133819Stjr 584133819Stjr error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 585133819Stjr if (error) 586133819Stjr return (error); 587133819Stjr 588133819Stjr#ifdef DEBUG 589133819Stjr if (ldebug(mmap)) 590133819Stjr printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"), 591133843Sobrien (void *)(intptr_t)linux_args.addr, linux_args.len, 592133843Sobrien linux_args.prot, linux_args.flags, linux_args.fd, 593133843Sobrien linux_args.pos); 594133819Stjr#endif 595144441Sjhb if ((linux_args.pgoff % PAGE_SIZE) != 0) 596144441Sjhb return (EINVAL); 597144441Sjhb linux_args.pgoff /= PAGE_SIZE; 598133819Stjr 599133819Stjr return (linux_mmap_common(td, &linux_args)); 600133819Stjr} 601133819Stjr 602133819Stjrstatic int 603133819Stjrlinux_mmap_common(struct thread *td, struct l_mmap_argv *linux_args) 604133819Stjr{ 605133819Stjr struct proc *p = td->td_proc; 606133819Stjr struct mmap_args /* { 607133819Stjr caddr_t addr; 608133819Stjr size_t len; 609133819Stjr int prot; 610133819Stjr int flags; 611133819Stjr int fd; 612133819Stjr long pad; 613133819Stjr off_t pos; 614133819Stjr } */ bsd_args; 615133819Stjr int error; 616133819Stjr 617133819Stjr error = 0; 618133819Stjr bsd_args.flags = 0; 619133819Stjr if (linux_args->flags & LINUX_MAP_SHARED) 620133819Stjr bsd_args.flags |= MAP_SHARED; 621133819Stjr if (linux_args->flags & LINUX_MAP_PRIVATE) 622133819Stjr bsd_args.flags |= MAP_PRIVATE; 623133819Stjr if (linux_args->flags & LINUX_MAP_FIXED) 624133819Stjr bsd_args.flags |= MAP_FIXED; 625133819Stjr if (linux_args->flags & LINUX_MAP_ANON) 626133819Stjr bsd_args.flags |= MAP_ANON; 627133819Stjr else 628133819Stjr bsd_args.flags |= MAP_NOSYNC; 629133819Stjr if (linux_args->flags & LINUX_MAP_GROWSDOWN) { 630133819Stjr bsd_args.flags |= MAP_STACK; 631133819Stjr 632133819Stjr /* The linux MAP_GROWSDOWN option does not limit auto 633133819Stjr * growth of the region. Linux mmap with this option 634133819Stjr * takes as addr the inital BOS, and as len, the initial 635133819Stjr * region size. It can then grow down from addr without 636133819Stjr * limit. However, linux threads has an implicit internal 637133819Stjr * limit to stack size of STACK_SIZE. Its just not 638133819Stjr * enforced explicitly in linux. But, here we impose 639133819Stjr * a limit of (STACK_SIZE - GUARD_SIZE) on the stack 640133819Stjr * region, since we can do this with our mmap. 641133819Stjr * 642133819Stjr * Our mmap with MAP_STACK takes addr as the maximum 643133819Stjr * downsize limit on BOS, and as len the max size of 644133819Stjr * the region. It them maps the top SGROWSIZ bytes, 645133819Stjr * and autgrows the region down, up to the limit 646133819Stjr * in addr. 647133819Stjr * 648133819Stjr * If we don't use the MAP_STACK option, the effect 649133819Stjr * of this code is to allocate a stack region of a 650133819Stjr * fixed size of (STACK_SIZE - GUARD_SIZE). 651133819Stjr */ 652133819Stjr 653133819Stjr /* This gives us TOS */ 654133819Stjr bsd_args.addr = (caddr_t)PTRIN(linux_args->addr) + 655133819Stjr linux_args->len; 656133819Stjr 657133819Stjr if ((caddr_t)PTRIN(bsd_args.addr) > 658133819Stjr p->p_vmspace->vm_maxsaddr) { 659133819Stjr /* Some linux apps will attempt to mmap 660133819Stjr * thread stacks near the top of their 661133819Stjr * address space. If their TOS is greater 662133819Stjr * than vm_maxsaddr, vm_map_growstack() 663133819Stjr * will confuse the thread stack with the 664133819Stjr * process stack and deliver a SEGV if they 665133819Stjr * attempt to grow the thread stack past their 666133819Stjr * current stacksize rlimit. To avoid this, 667133819Stjr * adjust vm_maxsaddr upwards to reflect 668133819Stjr * the current stacksize rlimit rather 669133819Stjr * than the maximum possible stacksize. 670133819Stjr * It would be better to adjust the 671133819Stjr * mmap'ed region, but some apps do not check 672133819Stjr * mmap's return value. 673133819Stjr */ 674133819Stjr PROC_LOCK(p); 675133819Stjr p->p_vmspace->vm_maxsaddr = 676133819Stjr (char *)LINUX32_USRSTACK - 677133819Stjr lim_cur(p, RLIMIT_STACK); 678133819Stjr PROC_UNLOCK(p); 679133819Stjr } 680133819Stjr 681133819Stjr /* This gives us our maximum stack size */ 682133819Stjr if (linux_args->len > STACK_SIZE - GUARD_SIZE) 683133819Stjr bsd_args.len = linux_args->len; 684133819Stjr else 685133819Stjr bsd_args.len = STACK_SIZE - GUARD_SIZE; 686133819Stjr 687133819Stjr /* This gives us a new BOS. If we're using VM_STACK, then 688133819Stjr * mmap will just map the top SGROWSIZ bytes, and let 689133819Stjr * the stack grow down to the limit at BOS. If we're 690133819Stjr * not using VM_STACK we map the full stack, since we 691133819Stjr * don't have a way to autogrow it. 692133819Stjr */ 693133819Stjr bsd_args.addr -= bsd_args.len; 694133819Stjr } else { 695133819Stjr bsd_args.addr = (caddr_t)PTRIN(linux_args->addr); 696133819Stjr bsd_args.len = linux_args->len; 697133819Stjr } 698133819Stjr /* 699133819Stjr * XXX i386 Linux always emulator forces PROT_READ on (why?) 700133819Stjr * so we do the same. We add PROT_EXEC to work around buggy 701133819Stjr * applications (e.g. Java) that take advantage of the fact 702133819Stjr * that execute permissions are not enforced by x86 CPUs. 703133819Stjr */ 704133819Stjr bsd_args.prot = linux_args->prot | PROT_EXEC | PROT_READ; 705133819Stjr if (linux_args->flags & LINUX_MAP_ANON) 706133819Stjr bsd_args.fd = -1; 707133819Stjr else 708133819Stjr bsd_args.fd = linux_args->fd; 709144441Sjhb bsd_args.pos = (off_t)linux_args->pgoff * PAGE_SIZE; 710133819Stjr bsd_args.pad = 0; 711133819Stjr 712133819Stjr#ifdef DEBUG 713133819Stjr if (ldebug(mmap)) 714133819Stjr printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n", 715133819Stjr __func__, 716133843Sobrien (void *)bsd_args.addr, (int)bsd_args.len, bsd_args.prot, 717133819Stjr bsd_args.flags, bsd_args.fd, (int)bsd_args.pos); 718133819Stjr#endif 719133819Stjr error = mmap(td, &bsd_args); 720133819Stjr#ifdef DEBUG 721133819Stjr if (ldebug(mmap)) 722133819Stjr printf("-> %s() return: 0x%x (0x%08x)\n", 723133819Stjr __func__, error, (u_int)td->td_retval[0]); 724133819Stjr#endif 725133819Stjr return (error); 726133819Stjr} 727133819Stjr 728133819Stjrint 729133819Stjrlinux_pipe(struct thread *td, struct linux_pipe_args *args) 730133819Stjr{ 731133819Stjr int pip[2]; 732133819Stjr int error; 733133819Stjr register_t reg_rdx; 734133819Stjr 735133819Stjr#ifdef DEBUG 736133819Stjr if (ldebug(pipe)) 737133819Stjr printf(ARGS(pipe, "*")); 738133819Stjr#endif 739133819Stjr 740133819Stjr reg_rdx = td->td_retval[1]; 741133819Stjr error = pipe(td, 0); 742133819Stjr if (error) { 743133819Stjr td->td_retval[1] = reg_rdx; 744133819Stjr return (error); 745133819Stjr } 746133819Stjr 747133819Stjr pip[0] = td->td_retval[0]; 748133819Stjr pip[1] = td->td_retval[1]; 749133819Stjr error = copyout(pip, args->pipefds, 2 * sizeof(int)); 750133819Stjr if (error) { 751133819Stjr td->td_retval[1] = reg_rdx; 752133819Stjr return (error); 753133819Stjr } 754133819Stjr 755133819Stjr td->td_retval[1] = reg_rdx; 756133819Stjr td->td_retval[0] = 0; 757133819Stjr return (0); 758133819Stjr} 759133819Stjr 760133819Stjrint 761133819Stjrlinux_sigaction(struct thread *td, struct linux_sigaction_args *args) 762133819Stjr{ 763133819Stjr l_osigaction_t osa; 764133819Stjr l_sigaction_t act, oact; 765133819Stjr int error; 766133819Stjr 767133819Stjr#ifdef DEBUG 768133819Stjr if (ldebug(sigaction)) 769133819Stjr printf(ARGS(sigaction, "%d, %p, %p"), 770133819Stjr args->sig, (void *)args->nsa, (void *)args->osa); 771133819Stjr#endif 772133819Stjr 773133819Stjr if (args->nsa != NULL) { 774133819Stjr error = copyin(args->nsa, &osa, sizeof(l_osigaction_t)); 775133819Stjr if (error) 776133819Stjr return (error); 777133819Stjr act.lsa_handler = osa.lsa_handler; 778133819Stjr act.lsa_flags = osa.lsa_flags; 779133819Stjr act.lsa_restorer = osa.lsa_restorer; 780133819Stjr LINUX_SIGEMPTYSET(act.lsa_mask); 781133819Stjr act.lsa_mask.__bits[0] = osa.lsa_mask; 782133819Stjr } 783133819Stjr 784133819Stjr error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, 785133819Stjr args->osa ? &oact : NULL); 786133819Stjr 787133819Stjr if (args->osa != NULL && !error) { 788133819Stjr osa.lsa_handler = oact.lsa_handler; 789133819Stjr osa.lsa_flags = oact.lsa_flags; 790133819Stjr osa.lsa_restorer = oact.lsa_restorer; 791133819Stjr osa.lsa_mask = oact.lsa_mask.__bits[0]; 792133819Stjr error = copyout(&osa, args->osa, sizeof(l_osigaction_t)); 793133819Stjr } 794133819Stjr 795133819Stjr return (error); 796133819Stjr} 797133819Stjr 798133819Stjr/* 799133819Stjr * Linux has two extra args, restart and oldmask. We dont use these, 800133819Stjr * but it seems that "restart" is actually a context pointer that 801133819Stjr * enables the signal to happen with a different register set. 802133819Stjr */ 803133819Stjrint 804133819Stjrlinux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) 805133819Stjr{ 806133819Stjr sigset_t sigmask; 807133819Stjr l_sigset_t mask; 808133819Stjr 809133819Stjr#ifdef DEBUG 810133819Stjr if (ldebug(sigsuspend)) 811133819Stjr printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask); 812133819Stjr#endif 813133819Stjr 814133819Stjr LINUX_SIGEMPTYSET(mask); 815133819Stjr mask.__bits[0] = args->mask; 816133819Stjr linux_to_bsd_sigset(&mask, &sigmask); 817133819Stjr return (kern_sigsuspend(td, sigmask)); 818133819Stjr} 819133819Stjr 820133819Stjrint 821133819Stjrlinux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap) 822133819Stjr{ 823133819Stjr l_sigset_t lmask; 824133819Stjr sigset_t sigmask; 825133819Stjr int error; 826133819Stjr 827133819Stjr#ifdef DEBUG 828133819Stjr if (ldebug(rt_sigsuspend)) 829133819Stjr printf(ARGS(rt_sigsuspend, "%p, %d"), 830133819Stjr (void *)uap->newset, uap->sigsetsize); 831133819Stjr#endif 832133819Stjr 833133819Stjr if (uap->sigsetsize != sizeof(l_sigset_t)) 834133819Stjr return (EINVAL); 835133819Stjr 836133819Stjr error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); 837133819Stjr if (error) 838133819Stjr return (error); 839133819Stjr 840133819Stjr linux_to_bsd_sigset(&lmask, &sigmask); 841133819Stjr return (kern_sigsuspend(td, sigmask)); 842133819Stjr} 843133819Stjr 844133819Stjrint 845133819Stjrlinux_pause(struct thread *td, struct linux_pause_args *args) 846133819Stjr{ 847133819Stjr struct proc *p = td->td_proc; 848133819Stjr sigset_t sigmask; 849133819Stjr 850133819Stjr#ifdef DEBUG 851133819Stjr if (ldebug(pause)) 852133819Stjr printf(ARGS(pause, "")); 853133819Stjr#endif 854133819Stjr 855133819Stjr PROC_LOCK(p); 856133819Stjr sigmask = td->td_sigmask; 857133819Stjr PROC_UNLOCK(p); 858133819Stjr return (kern_sigsuspend(td, sigmask)); 859133819Stjr} 860133819Stjr 861133819Stjrint 862133819Stjrlinux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) 863133819Stjr{ 864133819Stjr stack_t ss, oss; 865133819Stjr l_stack_t lss; 866133819Stjr int error; 867133819Stjr 868133819Stjr#ifdef DEBUG 869133819Stjr if (ldebug(sigaltstack)) 870133819Stjr printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss); 871133819Stjr#endif 872133819Stjr 873133819Stjr if (uap->uss != NULL) { 874133819Stjr error = copyin(uap->uss, &lss, sizeof(l_stack_t)); 875133819Stjr if (error) 876133819Stjr return (error); 877133819Stjr 878133819Stjr ss.ss_sp = PTRIN(lss.ss_sp); 879133819Stjr ss.ss_size = lss.ss_size; 880133819Stjr ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags); 881133819Stjr } 882134269Sjhb error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL, 883134269Sjhb (uap->uoss != NULL) ? &oss : NULL); 884133819Stjr if (!error && uap->uoss != NULL) { 885133819Stjr lss.ss_sp = PTROUT(oss.ss_sp); 886133819Stjr lss.ss_size = oss.ss_size; 887133819Stjr lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags); 888133819Stjr error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); 889133819Stjr } 890133819Stjr 891133819Stjr return (error); 892133819Stjr} 893133819Stjr 894133819Stjrint 895133819Stjrlinux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) 896133819Stjr{ 897133819Stjr struct ftruncate_args sa; 898133819Stjr 899133819Stjr#ifdef DEBUG 900133819Stjr if (ldebug(ftruncate64)) 901133819Stjr printf(ARGS(ftruncate64, "%u, %jd"), args->fd, 902133819Stjr (intmax_t)args->length); 903133819Stjr#endif 904133819Stjr 905133819Stjr sa.fd = args->fd; 906133819Stjr sa.pad = 0; 907133819Stjr sa.length = args->length; 908133819Stjr return ftruncate(td, &sa); 909133819Stjr} 910133819Stjr 911133819Stjrint 912133819Stjrlinux_gettimeofday(struct thread *td, struct linux_gettimeofday_args *uap) 913133819Stjr{ 914133819Stjr struct timeval atv; 915133819Stjr l_timeval atv32; 916133819Stjr struct timezone rtz; 917133819Stjr int error = 0; 918133819Stjr 919133819Stjr if (uap->tp) { 920133819Stjr microtime(&atv); 921133819Stjr atv32.tv_sec = atv.tv_sec; 922133819Stjr atv32.tv_usec = atv.tv_usec; 923133819Stjr error = copyout(&atv32, uap->tp, sizeof (atv32)); 924133819Stjr } 925133819Stjr if (error == 0 && uap->tzp != NULL) { 926133819Stjr rtz.tz_minuteswest = tz_minuteswest; 927133819Stjr rtz.tz_dsttime = tz_dsttime; 928133819Stjr error = copyout(&rtz, uap->tzp, sizeof (rtz)); 929133819Stjr } 930133819Stjr return (error); 931133819Stjr} 932133819Stjr 933133819Stjrint 934133819Stjrlinux_nanosleep(struct thread *td, struct linux_nanosleep_args *uap) 935133819Stjr{ 936142057Sjhb struct timespec rqt, rmt; 937133819Stjr struct l_timespec ats32; 938133819Stjr int error; 939133819Stjr 940133819Stjr error = copyin(uap->rqtp, &ats32, sizeof(ats32)); 941133819Stjr if (error != 0) 942133819Stjr return (error); 943142057Sjhb rqt.tv_sec = ats32.tv_sec; 944142057Sjhb rqt.tv_nsec = ats32.tv_nsec; 945142057Sjhb error = kern_nanosleep(td, &rqt, &rmt); 946133819Stjr if (uap->rmtp != NULL) { 947142057Sjhb ats32.tv_sec = rmt.tv_sec; 948142057Sjhb ats32.tv_nsec = rmt.tv_nsec; 949133819Stjr error = copyout(&ats32, uap->rmtp, sizeof(ats32)); 950133819Stjr } 951133819Stjr return (error); 952133819Stjr} 953133819Stjr 954133819Stjrint 955133819Stjrlinux_getrusage(struct thread *td, struct linux_getrusage_args *uap) 956133819Stjr{ 957136152Sjhb struct l_rusage s32; 958136152Sjhb struct rusage s; 959133819Stjr int error; 960133819Stjr 961136152Sjhb error = kern_getrusage(td, uap->who, &s); 962133819Stjr if (error != 0) 963133819Stjr return (error); 964136152Sjhb if (uap->rusage != NULL) { 965133819Stjr s32.ru_utime.tv_sec = s.ru_utime.tv_sec; 966133819Stjr s32.ru_utime.tv_usec = s.ru_utime.tv_usec; 967133819Stjr s32.ru_stime.tv_sec = s.ru_stime.tv_sec; 968133819Stjr s32.ru_stime.tv_usec = s.ru_stime.tv_usec; 969133819Stjr s32.ru_maxrss = s.ru_maxrss; 970133819Stjr s32.ru_ixrss = s.ru_ixrss; 971133819Stjr s32.ru_idrss = s.ru_idrss; 972133819Stjr s32.ru_isrss = s.ru_isrss; 973133819Stjr s32.ru_minflt = s.ru_minflt; 974133819Stjr s32.ru_majflt = s.ru_majflt; 975133819Stjr s32.ru_nswap = s.ru_nswap; 976133819Stjr s32.ru_inblock = s.ru_inblock; 977133819Stjr s32.ru_oublock = s.ru_oublock; 978133819Stjr s32.ru_msgsnd = s.ru_msgsnd; 979133819Stjr s32.ru_msgrcv = s.ru_msgrcv; 980133819Stjr s32.ru_nsignals = s.ru_nsignals; 981133819Stjr s32.ru_nvcsw = s.ru_nvcsw; 982133819Stjr s32.ru_nivcsw = s.ru_nivcsw; 983136152Sjhb error = copyout(&s32, uap->rusage, sizeof(s32)); 984133819Stjr } 985133819Stjr return (error); 986133819Stjr} 987133819Stjr 988133819Stjrint 989133819Stjrlinux_sched_rr_get_interval(struct thread *td, 990133819Stjr struct linux_sched_rr_get_interval_args *uap) 991133819Stjr{ 992133819Stjr struct timespec ts; 993133819Stjr struct l_timespec ts32; 994133819Stjr int error; 995133819Stjr 996144449Sjhb error = kern_sched_rr_get_interval(td, uap->pid, &ts); 997133819Stjr if (error != 0) 998133819Stjr return (error); 999133819Stjr ts32.tv_sec = ts.tv_sec; 1000133819Stjr ts32.tv_nsec = ts.tv_nsec; 1001133819Stjr return (copyout(&ts32, uap->interval, sizeof(ts32))); 1002133819Stjr} 1003133819Stjr 1004133819Stjrint 1005133819Stjrlinux_mprotect(struct thread *td, struct linux_mprotect_args *uap) 1006133819Stjr{ 1007133819Stjr struct mprotect_args bsd_args; 1008133819Stjr 1009133819Stjr bsd_args.addr = uap->addr; 1010133819Stjr bsd_args.len = uap->len; 1011133819Stjr bsd_args.prot = uap->prot; 1012133819Stjr /* XXX PROT_READ implies PROT_EXEC; see linux_mmap_common(). */ 1013133819Stjr if ((bsd_args.prot & PROT_READ) != 0) 1014133819Stjr bsd_args.prot |= PROT_EXEC; 1015133819Stjr return (mprotect(td, &bsd_args)); 1016133819Stjr} 1017