1146aad74SMarcel Moolenaar /*- 2146aad74SMarcel Moolenaar * Copyright (c) 2000 Marcel Moolenaar 3146aad74SMarcel Moolenaar * All rights reserved. 4146aad74SMarcel Moolenaar * 5146aad74SMarcel Moolenaar * Redistribution and use in source and binary forms, with or without 6146aad74SMarcel Moolenaar * modification, are permitted provided that the following conditions 7146aad74SMarcel Moolenaar * are met: 8146aad74SMarcel Moolenaar * 1. Redistributions of source code must retain the above copyright 9146aad74SMarcel Moolenaar * notice, this list of conditions and the following disclaimer 10146aad74SMarcel Moolenaar * in this position and unchanged. 11146aad74SMarcel Moolenaar * 2. Redistributions in binary form must reproduce the above copyright 12146aad74SMarcel Moolenaar * notice, this list of conditions and the following disclaimer in the 13146aad74SMarcel Moolenaar * documentation and/or other materials provided with the distribution. 14146aad74SMarcel Moolenaar * 3. The name of the author may not be used to endorse or promote products 15bc34729cSMarcel Moolenaar * derived from this software without specific prior written permission. 16146aad74SMarcel Moolenaar * 17146aad74SMarcel Moolenaar * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18146aad74SMarcel Moolenaar * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19146aad74SMarcel Moolenaar * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20146aad74SMarcel Moolenaar * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21146aad74SMarcel Moolenaar * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22146aad74SMarcel Moolenaar * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23146aad74SMarcel Moolenaar * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24146aad74SMarcel Moolenaar * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25146aad74SMarcel Moolenaar * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26146aad74SMarcel Moolenaar * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27146aad74SMarcel Moolenaar */ 28146aad74SMarcel Moolenaar 2927e0099cSDavid E. O'Brien #include <sys/cdefs.h> 3027e0099cSDavid E. O'Brien __FBSDID("$FreeBSD$"); 3127e0099cSDavid E. O'Brien 32146aad74SMarcel Moolenaar #include <sys/param.h> 33146aad74SMarcel Moolenaar #include <sys/systm.h> 347106ca0dSJohn Baldwin #include <sys/lock.h> 35fb919e4dSMark Murray #include <sys/mman.h> 36fb919e4dSMark Murray #include <sys/mutex.h> 37fb919e4dSMark Murray #include <sys/proc.h> 38242fae60SAndrew Gallatin #include <sys/resource.h> 39242fae60SAndrew Gallatin #include <sys/resourcevar.h> 401bc85c0dSDoug Rabson #include <sys/signalvar.h> 41206a5d3aSIan Dowse #include <sys/syscallsubr.h> 42fb919e4dSMark Murray #include <sys/sysproto.h> 43fb919e4dSMark Murray #include <sys/unistd.h> 44146aad74SMarcel Moolenaar 45146aad74SMarcel Moolenaar #include <machine/frame.h> 46146aad74SMarcel Moolenaar #include <machine/psl.h> 47146aad74SMarcel Moolenaar #include <machine/segments.h> 48146aad74SMarcel Moolenaar #include <machine/sysarch.h> 49146aad74SMarcel Moolenaar 50242fae60SAndrew Gallatin #include <vm/vm.h> 51242fae60SAndrew Gallatin #include <vm/pmap.h> 52242fae60SAndrew Gallatin #include <vm/vm_map.h> 53242fae60SAndrew Gallatin 54146aad74SMarcel Moolenaar #include <i386/linux/linux.h> 55ebea8660SMarcel Moolenaar #include <i386/linux/linux_proto.h> 56146aad74SMarcel Moolenaar #include <compat/linux/linux_ipc.h> 57146aad74SMarcel Moolenaar #include <compat/linux/linux_signal.h> 58146aad74SMarcel Moolenaar #include <compat/linux/linux_util.h> 59146aad74SMarcel Moolenaar 605002a60fSMarcel Moolenaar struct l_descriptor { 615002a60fSMarcel Moolenaar l_uint entry_number; 625002a60fSMarcel Moolenaar l_ulong base_addr; 635002a60fSMarcel Moolenaar l_uint limit; 645002a60fSMarcel Moolenaar l_uint seg_32bit:1; 655002a60fSMarcel Moolenaar l_uint contents:2; 665002a60fSMarcel Moolenaar l_uint read_exec_only:1; 675002a60fSMarcel Moolenaar l_uint limit_in_pages:1; 685002a60fSMarcel Moolenaar l_uint seg_not_present:1; 695002a60fSMarcel Moolenaar l_uint useable:1; 70146aad74SMarcel Moolenaar }; 71146aad74SMarcel Moolenaar 725002a60fSMarcel Moolenaar struct l_old_select_argv { 735002a60fSMarcel Moolenaar l_int nfds; 745002a60fSMarcel Moolenaar l_fd_set *readfds; 755002a60fSMarcel Moolenaar l_fd_set *writefds; 765002a60fSMarcel Moolenaar l_fd_set *exceptfds; 775002a60fSMarcel Moolenaar struct l_timeval *timeout; 78146aad74SMarcel Moolenaar }; 79146aad74SMarcel Moolenaar 80146aad74SMarcel Moolenaar int 81931a7258SAndrew Gallatin linux_to_bsd_sigaltstack(int lsa) 82931a7258SAndrew Gallatin { 83931a7258SAndrew Gallatin int bsa = 0; 84931a7258SAndrew Gallatin 85931a7258SAndrew Gallatin if (lsa & LINUX_SS_DISABLE) 86931a7258SAndrew Gallatin bsa |= SS_DISABLE; 87931a7258SAndrew Gallatin if (lsa & LINUX_SS_ONSTACK) 88931a7258SAndrew Gallatin bsa |= SS_ONSTACK; 89931a7258SAndrew Gallatin return (bsa); 90931a7258SAndrew Gallatin } 91931a7258SAndrew Gallatin 92931a7258SAndrew Gallatin int 93931a7258SAndrew Gallatin bsd_to_linux_sigaltstack(int bsa) 94931a7258SAndrew Gallatin { 95931a7258SAndrew Gallatin int lsa = 0; 96931a7258SAndrew Gallatin 97931a7258SAndrew Gallatin if (bsa & SS_DISABLE) 98931a7258SAndrew Gallatin lsa |= LINUX_SS_DISABLE; 99931a7258SAndrew Gallatin if (bsa & SS_ONSTACK) 100931a7258SAndrew Gallatin lsa |= LINUX_SS_ONSTACK; 101931a7258SAndrew Gallatin return (lsa); 102931a7258SAndrew Gallatin } 103931a7258SAndrew Gallatin 104931a7258SAndrew Gallatin int 105b40ce416SJulian Elischer linux_execve(struct thread *td, struct linux_execve_args *args) 106146aad74SMarcel Moolenaar { 107146aad74SMarcel Moolenaar struct execve_args bsd; 108146aad74SMarcel Moolenaar caddr_t sg; 109146aad74SMarcel Moolenaar 110146aad74SMarcel Moolenaar sg = stackgap_init(); 111b40ce416SJulian Elischer CHECKALTEXIST(td, &sg, args->path); 112146aad74SMarcel Moolenaar 113146aad74SMarcel Moolenaar #ifdef DEBUG 11424593369SJonathan Lemon if (ldebug(execve)) 11524593369SJonathan Lemon printf(ARGS(execve, "%s"), args->path); 116146aad74SMarcel Moolenaar #endif 117146aad74SMarcel Moolenaar 118146aad74SMarcel Moolenaar bsd.fname = args->path; 119146aad74SMarcel Moolenaar bsd.argv = args->argp; 120146aad74SMarcel Moolenaar bsd.envv = args->envp; 121b40ce416SJulian Elischer return (execve(td, &bsd)); 122146aad74SMarcel Moolenaar } 123146aad74SMarcel Moolenaar 1245002a60fSMarcel Moolenaar struct l_ipc_kludge { 1255002a60fSMarcel Moolenaar struct l_msgbuf *msgp; 1265002a60fSMarcel Moolenaar l_long msgtyp; 1275002a60fSMarcel Moolenaar }; 1285002a60fSMarcel Moolenaar 129146aad74SMarcel Moolenaar int 130b40ce416SJulian Elischer linux_ipc(struct thread *td, struct linux_ipc_args *args) 131146aad74SMarcel Moolenaar { 1325002a60fSMarcel Moolenaar 1335002a60fSMarcel Moolenaar switch (args->what & 0xFFFF) { 1345002a60fSMarcel Moolenaar case LINUX_SEMOP: { 1355002a60fSMarcel Moolenaar struct linux_semop_args a; 1365002a60fSMarcel Moolenaar 1375002a60fSMarcel Moolenaar a.semid = args->arg1; 1385002a60fSMarcel Moolenaar a.tsops = args->ptr; 1395002a60fSMarcel Moolenaar a.nsops = args->arg2; 140b40ce416SJulian Elischer return (linux_semop(td, &a)); 1415002a60fSMarcel Moolenaar } 1425002a60fSMarcel Moolenaar case LINUX_SEMGET: { 1435002a60fSMarcel Moolenaar struct linux_semget_args a; 1445002a60fSMarcel Moolenaar 1455002a60fSMarcel Moolenaar a.key = args->arg1; 1465002a60fSMarcel Moolenaar a.nsems = args->arg2; 1475002a60fSMarcel Moolenaar a.semflg = args->arg3; 148b40ce416SJulian Elischer return (linux_semget(td, &a)); 1495002a60fSMarcel Moolenaar } 1505002a60fSMarcel Moolenaar case LINUX_SEMCTL: { 1515002a60fSMarcel Moolenaar struct linux_semctl_args a; 1525002a60fSMarcel Moolenaar int error; 1535002a60fSMarcel Moolenaar 1545002a60fSMarcel Moolenaar a.semid = args->arg1; 1555002a60fSMarcel Moolenaar a.semnum = args->arg2; 1565002a60fSMarcel Moolenaar a.cmd = args->arg3; 1574b7ef73dSDag-Erling Smørgrav error = copyin(args->ptr, &a.arg, sizeof(a.arg)); 1585002a60fSMarcel Moolenaar if (error) 1595002a60fSMarcel Moolenaar return (error); 160b40ce416SJulian Elischer return (linux_semctl(td, &a)); 1615002a60fSMarcel Moolenaar } 1625002a60fSMarcel Moolenaar case LINUX_MSGSND: { 1635002a60fSMarcel Moolenaar struct linux_msgsnd_args a; 1645002a60fSMarcel Moolenaar 1655002a60fSMarcel Moolenaar a.msqid = args->arg1; 1665002a60fSMarcel Moolenaar a.msgp = args->ptr; 1675002a60fSMarcel Moolenaar a.msgsz = args->arg2; 1685002a60fSMarcel Moolenaar a.msgflg = args->arg3; 169b40ce416SJulian Elischer return (linux_msgsnd(td, &a)); 1705002a60fSMarcel Moolenaar } 1715002a60fSMarcel Moolenaar case LINUX_MSGRCV: { 1725002a60fSMarcel Moolenaar struct linux_msgrcv_args a; 1735002a60fSMarcel Moolenaar 1745002a60fSMarcel Moolenaar a.msqid = args->arg1; 1755002a60fSMarcel Moolenaar a.msgsz = args->arg2; 1765002a60fSMarcel Moolenaar a.msgflg = args->arg3; 1775002a60fSMarcel Moolenaar if ((args->what >> 16) == 0) { 1785002a60fSMarcel Moolenaar struct l_ipc_kludge tmp; 1795002a60fSMarcel Moolenaar int error; 1805002a60fSMarcel Moolenaar 1815002a60fSMarcel Moolenaar if (args->ptr == NULL) 1825002a60fSMarcel Moolenaar return (EINVAL); 1834b7ef73dSDag-Erling Smørgrav error = copyin(args->ptr, &tmp, sizeof(tmp)); 1845002a60fSMarcel Moolenaar if (error) 1855002a60fSMarcel Moolenaar return (error); 1865002a60fSMarcel Moolenaar a.msgp = tmp.msgp; 1875002a60fSMarcel Moolenaar a.msgtyp = tmp.msgtyp; 1885002a60fSMarcel Moolenaar } else { 1895002a60fSMarcel Moolenaar a.msgp = args->ptr; 1905002a60fSMarcel Moolenaar a.msgtyp = args->arg5; 1915002a60fSMarcel Moolenaar } 192b40ce416SJulian Elischer return (linux_msgrcv(td, &a)); 1935002a60fSMarcel Moolenaar } 1945002a60fSMarcel Moolenaar case LINUX_MSGGET: { 1955002a60fSMarcel Moolenaar struct linux_msgget_args a; 1965002a60fSMarcel Moolenaar 1975002a60fSMarcel Moolenaar a.key = args->arg1; 1985002a60fSMarcel Moolenaar a.msgflg = args->arg2; 199b40ce416SJulian Elischer return (linux_msgget(td, &a)); 2005002a60fSMarcel Moolenaar } 2015002a60fSMarcel Moolenaar case LINUX_MSGCTL: { 2025002a60fSMarcel Moolenaar struct linux_msgctl_args a; 2035002a60fSMarcel Moolenaar 2045002a60fSMarcel Moolenaar a.msqid = args->arg1; 2055002a60fSMarcel Moolenaar a.cmd = args->arg2; 2065002a60fSMarcel Moolenaar a.buf = args->ptr; 207b40ce416SJulian Elischer return (linux_msgctl(td, &a)); 2085002a60fSMarcel Moolenaar } 2095002a60fSMarcel Moolenaar case LINUX_SHMAT: { 2105002a60fSMarcel Moolenaar struct linux_shmat_args a; 2115002a60fSMarcel Moolenaar 2125002a60fSMarcel Moolenaar a.shmid = args->arg1; 2135002a60fSMarcel Moolenaar a.shmaddr = args->ptr; 2145002a60fSMarcel Moolenaar a.shmflg = args->arg2; 2155002a60fSMarcel Moolenaar a.raddr = (l_ulong *)args->arg3; 216b40ce416SJulian Elischer return (linux_shmat(td, &a)); 2175002a60fSMarcel Moolenaar } 2185002a60fSMarcel Moolenaar case LINUX_SHMDT: { 2195002a60fSMarcel Moolenaar struct linux_shmdt_args a; 2205002a60fSMarcel Moolenaar 2215002a60fSMarcel Moolenaar a.shmaddr = args->ptr; 222b40ce416SJulian Elischer return (linux_shmdt(td, &a)); 2235002a60fSMarcel Moolenaar } 2245002a60fSMarcel Moolenaar case LINUX_SHMGET: { 2255002a60fSMarcel Moolenaar struct linux_shmget_args a; 2265002a60fSMarcel Moolenaar 2275002a60fSMarcel Moolenaar a.key = args->arg1; 2285002a60fSMarcel Moolenaar a.size = args->arg2; 2295002a60fSMarcel Moolenaar a.shmflg = args->arg3; 230b40ce416SJulian Elischer return (linux_shmget(td, &a)); 2315002a60fSMarcel Moolenaar } 2325002a60fSMarcel Moolenaar case LINUX_SHMCTL: { 2335002a60fSMarcel Moolenaar struct linux_shmctl_args a; 2345002a60fSMarcel Moolenaar 2355002a60fSMarcel Moolenaar a.shmid = args->arg1; 2365002a60fSMarcel Moolenaar a.cmd = args->arg2; 2375002a60fSMarcel Moolenaar a.buf = args->ptr; 238b40ce416SJulian Elischer return (linux_shmctl(td, &a)); 2395002a60fSMarcel Moolenaar } 2405002a60fSMarcel Moolenaar default: 2415002a60fSMarcel Moolenaar break; 242146aad74SMarcel Moolenaar } 243146aad74SMarcel Moolenaar 2445002a60fSMarcel Moolenaar return (EINVAL); 245146aad74SMarcel Moolenaar } 246146aad74SMarcel Moolenaar 247146aad74SMarcel Moolenaar int 248b40ce416SJulian Elischer linux_old_select(struct thread *td, struct linux_old_select_args *args) 249146aad74SMarcel Moolenaar { 2505002a60fSMarcel Moolenaar struct l_old_select_argv linux_args; 2515002a60fSMarcel Moolenaar struct linux_select_args newsel; 252146aad74SMarcel Moolenaar int error; 253146aad74SMarcel Moolenaar 2545002a60fSMarcel Moolenaar #ifdef DEBUG 2555002a60fSMarcel Moolenaar if (ldebug(old_select)) 2566aea6777SPeter Wemm printf(ARGS(old_select, "%p"), args->ptr); 257146aad74SMarcel Moolenaar #endif 258146aad74SMarcel Moolenaar 2594b7ef73dSDag-Erling Smørgrav error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 260146aad74SMarcel Moolenaar if (error) 261146aad74SMarcel Moolenaar return (error); 262146aad74SMarcel Moolenaar 263146aad74SMarcel Moolenaar newsel.nfds = linux_args.nfds; 264146aad74SMarcel Moolenaar newsel.readfds = linux_args.readfds; 265146aad74SMarcel Moolenaar newsel.writefds = linux_args.writefds; 266146aad74SMarcel Moolenaar newsel.exceptfds = linux_args.exceptfds; 267146aad74SMarcel Moolenaar newsel.timeout = linux_args.timeout; 268b40ce416SJulian Elischer return (linux_select(td, &newsel)); 269146aad74SMarcel Moolenaar } 270146aad74SMarcel Moolenaar 271146aad74SMarcel Moolenaar int 272b40ce416SJulian Elischer linux_fork(struct thread *td, struct linux_fork_args *args) 273146aad74SMarcel Moolenaar { 274146aad74SMarcel Moolenaar int error; 275146aad74SMarcel Moolenaar 276146aad74SMarcel Moolenaar #ifdef DEBUG 27724593369SJonathan Lemon if (ldebug(fork)) 27824593369SJonathan Lemon printf(ARGS(fork, "")); 279146aad74SMarcel Moolenaar #endif 280146aad74SMarcel Moolenaar 281b40ce416SJulian Elischer if ((error = fork(td, (struct fork_args *)args)) != 0) 282146aad74SMarcel Moolenaar return (error); 283146aad74SMarcel Moolenaar 284b40ce416SJulian Elischer if (td->td_retval[1] == 1) 285b40ce416SJulian Elischer td->td_retval[0] = 0; 286146aad74SMarcel Moolenaar return (0); 287146aad74SMarcel Moolenaar } 288146aad74SMarcel Moolenaar 289146aad74SMarcel Moolenaar int 290b40ce416SJulian Elischer linux_vfork(struct thread *td, struct linux_vfork_args *args) 291146aad74SMarcel Moolenaar { 292146aad74SMarcel Moolenaar int error; 293146aad74SMarcel Moolenaar 294146aad74SMarcel Moolenaar #ifdef DEBUG 29524593369SJonathan Lemon if (ldebug(vfork)) 29624593369SJonathan Lemon printf(ARGS(vfork, "")); 297146aad74SMarcel Moolenaar #endif 298146aad74SMarcel Moolenaar 299b40ce416SJulian Elischer if ((error = vfork(td, (struct vfork_args *)args)) != 0) 300146aad74SMarcel Moolenaar return (error); 301146aad74SMarcel Moolenaar /* Are we the child? */ 302b40ce416SJulian Elischer if (td->td_retval[1] == 1) 303b40ce416SJulian Elischer td->td_retval[0] = 0; 304146aad74SMarcel Moolenaar return (0); 305146aad74SMarcel Moolenaar } 306146aad74SMarcel Moolenaar 307146aad74SMarcel Moolenaar #define CLONE_VM 0x100 308146aad74SMarcel Moolenaar #define CLONE_FS 0x200 309146aad74SMarcel Moolenaar #define CLONE_FILES 0x400 310146aad74SMarcel Moolenaar #define CLONE_SIGHAND 0x800 311146aad74SMarcel Moolenaar #define CLONE_PID 0x1000 312146aad74SMarcel Moolenaar 313146aad74SMarcel Moolenaar int 314b40ce416SJulian Elischer linux_clone(struct thread *td, struct linux_clone_args *args) 315146aad74SMarcel Moolenaar { 3166ad0e7c5SJohn Baldwin int error, ff = RFPROC | RFSTOPPED; 317146aad74SMarcel Moolenaar struct proc *p2; 3189eb78fcfSJohn Baldwin struct thread *td2; 319146aad74SMarcel Moolenaar int exit_signal; 320146aad74SMarcel Moolenaar 321146aad74SMarcel Moolenaar #ifdef DEBUG 32224593369SJonathan Lemon if (ldebug(clone)) { 32324593369SJonathan Lemon printf(ARGS(clone, "flags %x, stack %x"), 32424593369SJonathan Lemon (unsigned int)args->flags, (unsigned int)args->stack); 325146aad74SMarcel Moolenaar if (args->flags & CLONE_PID) 32624593369SJonathan Lemon printf(LMSG("CLONE_PID not yet supported")); 32724593369SJonathan Lemon } 328146aad74SMarcel Moolenaar #endif 329146aad74SMarcel Moolenaar 330146aad74SMarcel Moolenaar if (!args->stack) 331146aad74SMarcel Moolenaar return (EINVAL); 332146aad74SMarcel Moolenaar 333146aad74SMarcel Moolenaar exit_signal = args->flags & 0x000000ff; 334146aad74SMarcel Moolenaar if (exit_signal >= LINUX_NSIG) 335146aad74SMarcel Moolenaar return (EINVAL); 336146aad74SMarcel Moolenaar 337146aad74SMarcel Moolenaar if (exit_signal <= LINUX_SIGTBLSZ) 338146aad74SMarcel Moolenaar exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)]; 339146aad74SMarcel Moolenaar 340146aad74SMarcel Moolenaar if (args->flags & CLONE_VM) 341146aad74SMarcel Moolenaar ff |= RFMEM; 342146aad74SMarcel Moolenaar if (args->flags & CLONE_SIGHAND) 343146aad74SMarcel Moolenaar ff |= RFSIGSHARE; 344146aad74SMarcel Moolenaar if (!(args->flags & CLONE_FILES)) 345146aad74SMarcel Moolenaar ff |= RFFDG; 346146aad74SMarcel Moolenaar 347316ec49aSScott Long error = fork1(td, ff, 0, &p2); 3489eb78fcfSJohn Baldwin if (error) 3499eb78fcfSJohn Baldwin return (error); 3509eb78fcfSJohn Baldwin 351146aad74SMarcel Moolenaar 352fdfdfb78SJohn Baldwin PROC_LOCK(p2); 353146aad74SMarcel Moolenaar p2->p_sigparent = exit_signal; 3549eb78fcfSJohn Baldwin PROC_UNLOCK(p2); 3559eb78fcfSJohn Baldwin td2 = FIRST_THREAD_IN_PROC(p2); 3569eb78fcfSJohn Baldwin td2->td_frame->tf_esp = (unsigned int)args->stack; 357146aad74SMarcel Moolenaar 358146aad74SMarcel Moolenaar #ifdef DEBUG 35924593369SJonathan Lemon if (ldebug(clone)) 3609eb78fcfSJohn Baldwin printf(LMSG("clone: successful rfork to %ld, stack %p sig = %d"), 3619eb78fcfSJohn Baldwin (long)p2->p_pid, args->stack, exit_signal); 362146aad74SMarcel Moolenaar #endif 363146aad74SMarcel Moolenaar 3646ad0e7c5SJohn Baldwin /* 3656ad0e7c5SJohn Baldwin * Make this runnable after we are finished with it. 3666ad0e7c5SJohn Baldwin */ 3676ad0e7c5SJohn Baldwin mtx_lock_spin(&sched_lock); 3689eb78fcfSJohn Baldwin TD_SET_CAN_RUN(td2); 3692630e4c9SJulian Elischer setrunqueue(td2, SRQ_BORING); 3706ad0e7c5SJohn Baldwin mtx_unlock_spin(&sched_lock); 3716ad0e7c5SJohn Baldwin 3729eb78fcfSJohn Baldwin td->td_retval[0] = p2->p_pid; 3739eb78fcfSJohn Baldwin td->td_retval[1] = 0; 3749eb78fcfSJohn Baldwin return (0); 375146aad74SMarcel Moolenaar } 376146aad74SMarcel Moolenaar 377146aad74SMarcel Moolenaar /* XXX move */ 3785002a60fSMarcel Moolenaar struct l_mmap_argv { 3795002a60fSMarcel Moolenaar l_caddr_t addr; 3805002a60fSMarcel Moolenaar l_int len; 3815002a60fSMarcel Moolenaar l_int prot; 3825002a60fSMarcel Moolenaar l_int flags; 3835002a60fSMarcel Moolenaar l_int fd; 3845002a60fSMarcel Moolenaar l_int pos; 385146aad74SMarcel Moolenaar }; 386146aad74SMarcel Moolenaar 387146aad74SMarcel Moolenaar #define STACK_SIZE (2 * 1024 * 1024) 388146aad74SMarcel Moolenaar #define GUARD_SIZE (4 * PAGE_SIZE) 389146aad74SMarcel Moolenaar 3903ad9c842SMaxim Sobolev static int linux_mmap_common(struct thread *, struct l_mmap_argv *); 3913ad9c842SMaxim Sobolev 3923ad9c842SMaxim Sobolev int 3933ad9c842SMaxim Sobolev linux_mmap2(struct thread *td, struct linux_mmap2_args *args) 3943ad9c842SMaxim Sobolev { 3953ad9c842SMaxim Sobolev struct l_mmap_argv linux_args; 3963ad9c842SMaxim Sobolev 3973ad9c842SMaxim Sobolev #ifdef DEBUG 3983ad9c842SMaxim Sobolev if (ldebug(mmap2)) 3993ad9c842SMaxim Sobolev printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"), 4003ad9c842SMaxim Sobolev (void *)args->addr, args->len, args->prot, 4013ad9c842SMaxim Sobolev args->flags, args->fd, args->pgoff); 4023ad9c842SMaxim Sobolev #endif 4033ad9c842SMaxim Sobolev 4043ad9c842SMaxim Sobolev linux_args.addr = (l_caddr_t)args->addr; 4053ad9c842SMaxim Sobolev linux_args.len = args->len; 4063ad9c842SMaxim Sobolev linux_args.prot = args->prot; 4073ad9c842SMaxim Sobolev linux_args.flags = args->flags; 4083ad9c842SMaxim Sobolev linux_args.fd = args->fd; 4093ad9c842SMaxim Sobolev linux_args.pos = args->pgoff * PAGE_SIZE; 4103ad9c842SMaxim Sobolev 4113ad9c842SMaxim Sobolev return (linux_mmap_common(td, &linux_args)); 4123ad9c842SMaxim Sobolev } 4133ad9c842SMaxim Sobolev 414146aad74SMarcel Moolenaar int 415b40ce416SJulian Elischer linux_mmap(struct thread *td, struct linux_mmap_args *args) 416146aad74SMarcel Moolenaar { 4173ad9c842SMaxim Sobolev int error; 4183ad9c842SMaxim Sobolev struct l_mmap_argv linux_args; 4193ad9c842SMaxim Sobolev 4204b7ef73dSDag-Erling Smørgrav error = copyin(args->ptr, &linux_args, sizeof(linux_args)); 4213ad9c842SMaxim Sobolev if (error) 4223ad9c842SMaxim Sobolev return (error); 4233ad9c842SMaxim Sobolev 4243ad9c842SMaxim Sobolev #ifdef DEBUG 4253ad9c842SMaxim Sobolev if (ldebug(mmap)) 4263ad9c842SMaxim Sobolev printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"), 427b45bbfc3SBruce Evans (void *)linux_args.addr, linux_args.len, linux_args.prot, 428b45bbfc3SBruce Evans linux_args.flags, linux_args.fd, linux_args.pos); 4293ad9c842SMaxim Sobolev #endif 4303ad9c842SMaxim Sobolev 4313ad9c842SMaxim Sobolev return (linux_mmap_common(td, &linux_args)); 4323ad9c842SMaxim Sobolev } 4333ad9c842SMaxim Sobolev 4343ad9c842SMaxim Sobolev static int 4353ad9c842SMaxim Sobolev linux_mmap_common(struct thread *td, struct l_mmap_argv *linux_args) 4363ad9c842SMaxim Sobolev { 437b40ce416SJulian Elischer struct proc *p = td->td_proc; 438146aad74SMarcel Moolenaar struct mmap_args /* { 439146aad74SMarcel Moolenaar caddr_t addr; 440146aad74SMarcel Moolenaar size_t len; 441146aad74SMarcel Moolenaar int prot; 442146aad74SMarcel Moolenaar int flags; 443146aad74SMarcel Moolenaar int fd; 444146aad74SMarcel Moolenaar long pad; 445146aad74SMarcel Moolenaar off_t pos; 446146aad74SMarcel Moolenaar } */ bsd_args; 44791d631e5SMatthew N. Dodd int error; 448146aad74SMarcel Moolenaar 44991d631e5SMatthew N. Dodd error = 0; 450146aad74SMarcel Moolenaar bsd_args.flags = 0; 4513ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_SHARED) 452146aad74SMarcel Moolenaar bsd_args.flags |= MAP_SHARED; 4533ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_PRIVATE) 454146aad74SMarcel Moolenaar bsd_args.flags |= MAP_PRIVATE; 4553ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_FIXED) 456146aad74SMarcel Moolenaar bsd_args.flags |= MAP_FIXED; 4573ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_ANON) 458146aad74SMarcel Moolenaar bsd_args.flags |= MAP_ANON; 4590cc3ac8bSMatthew Dillon else 4600cc3ac8bSMatthew Dillon bsd_args.flags |= MAP_NOSYNC; 4613ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_GROWSDOWN) { 462146aad74SMarcel Moolenaar bsd_args.flags |= MAP_STACK; 463146aad74SMarcel Moolenaar 464146aad74SMarcel Moolenaar /* The linux MAP_GROWSDOWN option does not limit auto 465146aad74SMarcel Moolenaar * growth of the region. Linux mmap with this option 466146aad74SMarcel Moolenaar * takes as addr the inital BOS, and as len, the initial 467146aad74SMarcel Moolenaar * region size. It can then grow down from addr without 468146aad74SMarcel Moolenaar * limit. However, linux threads has an implicit internal 469146aad74SMarcel Moolenaar * limit to stack size of STACK_SIZE. Its just not 470146aad74SMarcel Moolenaar * enforced explicitly in linux. But, here we impose 471146aad74SMarcel Moolenaar * a limit of (STACK_SIZE - GUARD_SIZE) on the stack 472146aad74SMarcel Moolenaar * region, since we can do this with our mmap. 473146aad74SMarcel Moolenaar * 474146aad74SMarcel Moolenaar * Our mmap with MAP_STACK takes addr as the maximum 475146aad74SMarcel Moolenaar * downsize limit on BOS, and as len the max size of 476146aad74SMarcel Moolenaar * the region. It them maps the top SGROWSIZ bytes, 477146aad74SMarcel Moolenaar * and autgrows the region down, up to the limit 478146aad74SMarcel Moolenaar * in addr. 479146aad74SMarcel Moolenaar * 480146aad74SMarcel Moolenaar * If we don't use the MAP_STACK option, the effect 481146aad74SMarcel Moolenaar * of this code is to allocate a stack region of a 482146aad74SMarcel Moolenaar * fixed size of (STACK_SIZE - GUARD_SIZE). 483146aad74SMarcel Moolenaar */ 484146aad74SMarcel Moolenaar 485146aad74SMarcel Moolenaar /* This gives us TOS */ 4863ad9c842SMaxim Sobolev bsd_args.addr = linux_args->addr + linux_args->len; 487146aad74SMarcel Moolenaar 488242fae60SAndrew Gallatin if (bsd_args.addr > p->p_vmspace->vm_maxsaddr) { 489242fae60SAndrew Gallatin /* Some linux apps will attempt to mmap 490242fae60SAndrew Gallatin * thread stacks near the top of their 491242fae60SAndrew Gallatin * address space. If their TOS is greater 492242fae60SAndrew Gallatin * than vm_maxsaddr, vm_map_growstack() 493242fae60SAndrew Gallatin * will confuse the thread stack with the 494242fae60SAndrew Gallatin * process stack and deliver a SEGV if they 495242fae60SAndrew Gallatin * attempt to grow the thread stack past their 496242fae60SAndrew Gallatin * current stacksize rlimit. To avoid this, 497242fae60SAndrew Gallatin * adjust vm_maxsaddr upwards to reflect 498242fae60SAndrew Gallatin * the current stacksize rlimit rather 499242fae60SAndrew Gallatin * than the maximum possible stacksize. 500242fae60SAndrew Gallatin * It would be better to adjust the 501242fae60SAndrew Gallatin * mmap'ed region, but some apps do not check 502242fae60SAndrew Gallatin * mmap's return value. 503242fae60SAndrew Gallatin */ 50491d5354aSJohn Baldwin PROC_LOCK(p); 505242fae60SAndrew Gallatin p->p_vmspace->vm_maxsaddr = (char *)USRSTACK - 50691d5354aSJohn Baldwin lim_cur(p, RLIMIT_STACK); 50791d5354aSJohn Baldwin PROC_UNLOCK(p); 508242fae60SAndrew Gallatin } 509242fae60SAndrew Gallatin 510146aad74SMarcel Moolenaar /* This gives us our maximum stack size */ 5113ad9c842SMaxim Sobolev if (linux_args->len > STACK_SIZE - GUARD_SIZE) 5123ad9c842SMaxim Sobolev bsd_args.len = linux_args->len; 513146aad74SMarcel Moolenaar else 514146aad74SMarcel Moolenaar bsd_args.len = STACK_SIZE - GUARD_SIZE; 515146aad74SMarcel Moolenaar 516146aad74SMarcel Moolenaar /* This gives us a new BOS. If we're using VM_STACK, then 517146aad74SMarcel Moolenaar * mmap will just map the top SGROWSIZ bytes, and let 518146aad74SMarcel Moolenaar * the stack grow down to the limit at BOS. If we're 519146aad74SMarcel Moolenaar * not using VM_STACK we map the full stack, since we 520146aad74SMarcel Moolenaar * don't have a way to autogrow it. 521146aad74SMarcel Moolenaar */ 522146aad74SMarcel Moolenaar bsd_args.addr -= bsd_args.len; 523146aad74SMarcel Moolenaar } else { 5243ad9c842SMaxim Sobolev bsd_args.addr = linux_args->addr; 5253ad9c842SMaxim Sobolev bsd_args.len = linux_args->len; 526146aad74SMarcel Moolenaar } 527146aad74SMarcel Moolenaar 5283ad9c842SMaxim Sobolev bsd_args.prot = linux_args->prot | PROT_READ; /* always required */ 5293ad9c842SMaxim Sobolev if (linux_args->flags & LINUX_MAP_ANON) 530146aad74SMarcel Moolenaar bsd_args.fd = -1; 531146aad74SMarcel Moolenaar else 5323ad9c842SMaxim Sobolev bsd_args.fd = linux_args->fd; 5333ad9c842SMaxim Sobolev bsd_args.pos = linux_args->pos; 534146aad74SMarcel Moolenaar bsd_args.pad = 0; 535146aad74SMarcel Moolenaar 536146aad74SMarcel Moolenaar #ifdef DEBUG 53724593369SJonathan Lemon if (ldebug(mmap)) 53891d631e5SMatthew N. Dodd printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n", 53991d631e5SMatthew N. Dodd __func__, 54024593369SJonathan Lemon (void *)bsd_args.addr, bsd_args.len, bsd_args.prot, 54124593369SJonathan Lemon bsd_args.flags, bsd_args.fd, (int)bsd_args.pos); 542146aad74SMarcel Moolenaar #endif 54391d631e5SMatthew N. Dodd error = mmap(td, &bsd_args); 54491d631e5SMatthew N. Dodd #ifdef DEBUG 54591d631e5SMatthew N. Dodd if (ldebug(mmap)) 54691d631e5SMatthew N. Dodd printf("-> %s() return: 0x%x (0x%08x)\n", 54791d631e5SMatthew N. Dodd __func__, error, (u_int)td->td_retval[0]); 54891d631e5SMatthew N. Dodd #endif 54991d631e5SMatthew N. Dodd return (error); 550146aad74SMarcel Moolenaar } 551146aad74SMarcel Moolenaar 552146aad74SMarcel Moolenaar int 553b40ce416SJulian Elischer linux_pipe(struct thread *td, struct linux_pipe_args *args) 554146aad74SMarcel Moolenaar { 555146aad74SMarcel Moolenaar int error; 556146aad74SMarcel Moolenaar int reg_edx; 557146aad74SMarcel Moolenaar 558146aad74SMarcel Moolenaar #ifdef DEBUG 55924593369SJonathan Lemon if (ldebug(pipe)) 56024593369SJonathan Lemon printf(ARGS(pipe, "*")); 561146aad74SMarcel Moolenaar #endif 562146aad74SMarcel Moolenaar 563b40ce416SJulian Elischer reg_edx = td->td_retval[1]; 564b40ce416SJulian Elischer error = pipe(td, 0); 565146aad74SMarcel Moolenaar if (error) { 566b40ce416SJulian Elischer td->td_retval[1] = reg_edx; 567146aad74SMarcel Moolenaar return (error); 568146aad74SMarcel Moolenaar } 569146aad74SMarcel Moolenaar 570b40ce416SJulian Elischer error = copyout(td->td_retval, args->pipefds, 2*sizeof(int)); 571146aad74SMarcel Moolenaar if (error) { 572b40ce416SJulian Elischer td->td_retval[1] = reg_edx; 573146aad74SMarcel Moolenaar return (error); 574146aad74SMarcel Moolenaar } 575146aad74SMarcel Moolenaar 576b40ce416SJulian Elischer td->td_retval[1] = reg_edx; 577b40ce416SJulian Elischer td->td_retval[0] = 0; 578146aad74SMarcel Moolenaar return (0); 579146aad74SMarcel Moolenaar } 580146aad74SMarcel Moolenaar 581146aad74SMarcel Moolenaar int 582b40ce416SJulian Elischer linux_ioperm(struct thread *td, struct linux_ioperm_args *args) 583146aad74SMarcel Moolenaar { 584146aad74SMarcel Moolenaar struct sysarch_args sa; 585146aad74SMarcel Moolenaar struct i386_ioperm_args *iia; 586146aad74SMarcel Moolenaar caddr_t sg; 587146aad74SMarcel Moolenaar 588146aad74SMarcel Moolenaar sg = stackgap_init(); 589146aad74SMarcel Moolenaar iia = stackgap_alloc(&sg, sizeof(struct i386_ioperm_args)); 590146aad74SMarcel Moolenaar iia->start = args->start; 591146aad74SMarcel Moolenaar iia->length = args->length; 592146aad74SMarcel Moolenaar iia->enable = args->enable; 593146aad74SMarcel Moolenaar sa.op = I386_SET_IOPERM; 594146aad74SMarcel Moolenaar sa.parms = (char *)iia; 595b40ce416SJulian Elischer return (sysarch(td, &sa)); 596146aad74SMarcel Moolenaar } 597146aad74SMarcel Moolenaar 598146aad74SMarcel Moolenaar int 599b40ce416SJulian Elischer linux_iopl(struct thread *td, struct linux_iopl_args *args) 600146aad74SMarcel Moolenaar { 601146aad74SMarcel Moolenaar int error; 602146aad74SMarcel Moolenaar 603146aad74SMarcel Moolenaar if (args->level < 0 || args->level > 3) 604146aad74SMarcel Moolenaar return (EINVAL); 60544731cabSJohn Baldwin if ((error = suser(td)) != 0) 606146aad74SMarcel Moolenaar return (error); 607a854ed98SJohn Baldwin if ((error = securelevel_gt(td->td_ucred, 0)) != 0) 60841c42188SRobert Watson return (error); 609b40ce416SJulian Elischer td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) | 610146aad74SMarcel Moolenaar (args->level * (PSL_IOPL / 3)); 611146aad74SMarcel Moolenaar return (0); 612146aad74SMarcel Moolenaar } 613146aad74SMarcel Moolenaar 614146aad74SMarcel Moolenaar int 615b07cd97eSMark Murray linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap) 616146aad74SMarcel Moolenaar { 617146aad74SMarcel Moolenaar int error; 618146aad74SMarcel Moolenaar caddr_t sg; 619146aad74SMarcel Moolenaar struct sysarch_args args; 620146aad74SMarcel Moolenaar struct i386_ldt_args *ldt; 6215002a60fSMarcel Moolenaar struct l_descriptor ld; 622146aad74SMarcel Moolenaar union descriptor *desc; 623146aad74SMarcel Moolenaar 624146aad74SMarcel Moolenaar sg = stackgap_init(); 625146aad74SMarcel Moolenaar 626146aad74SMarcel Moolenaar if (uap->ptr == NULL) 627146aad74SMarcel Moolenaar return (EINVAL); 628146aad74SMarcel Moolenaar 629146aad74SMarcel Moolenaar switch (uap->func) { 630146aad74SMarcel Moolenaar case 0x00: /* read_ldt */ 631146aad74SMarcel Moolenaar ldt = stackgap_alloc(&sg, sizeof(*ldt)); 632146aad74SMarcel Moolenaar ldt->start = 0; 633146aad74SMarcel Moolenaar ldt->descs = uap->ptr; 634146aad74SMarcel Moolenaar ldt->num = uap->bytecount / sizeof(union descriptor); 635146aad74SMarcel Moolenaar args.op = I386_GET_LDT; 636146aad74SMarcel Moolenaar args.parms = (char*)ldt; 637b40ce416SJulian Elischer error = sysarch(td, &args); 638b40ce416SJulian Elischer td->td_retval[0] *= sizeof(union descriptor); 639146aad74SMarcel Moolenaar break; 640146aad74SMarcel Moolenaar case 0x01: /* write_ldt */ 641146aad74SMarcel Moolenaar case 0x11: /* write_ldt */ 642146aad74SMarcel Moolenaar if (uap->bytecount != sizeof(ld)) 643146aad74SMarcel Moolenaar return (EINVAL); 644146aad74SMarcel Moolenaar 645146aad74SMarcel Moolenaar error = copyin(uap->ptr, &ld, sizeof(ld)); 646146aad74SMarcel Moolenaar if (error) 647146aad74SMarcel Moolenaar return (error); 648146aad74SMarcel Moolenaar 649146aad74SMarcel Moolenaar ldt = stackgap_alloc(&sg, sizeof(*ldt)); 650146aad74SMarcel Moolenaar desc = stackgap_alloc(&sg, sizeof(*desc)); 651146aad74SMarcel Moolenaar ldt->start = ld.entry_number; 652146aad74SMarcel Moolenaar ldt->descs = desc; 653146aad74SMarcel Moolenaar ldt->num = 1; 654146aad74SMarcel Moolenaar desc->sd.sd_lolimit = (ld.limit & 0x0000ffff); 655146aad74SMarcel Moolenaar desc->sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16; 656146aad74SMarcel Moolenaar desc->sd.sd_lobase = (ld.base_addr & 0x00ffffff); 657146aad74SMarcel Moolenaar desc->sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24; 658146aad74SMarcel Moolenaar desc->sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) | 659146aad74SMarcel Moolenaar (ld.contents << 2); 660146aad74SMarcel Moolenaar desc->sd.sd_dpl = 3; 661146aad74SMarcel Moolenaar desc->sd.sd_p = (ld.seg_not_present ^ 1); 662146aad74SMarcel Moolenaar desc->sd.sd_xx = 0; 663146aad74SMarcel Moolenaar desc->sd.sd_def32 = ld.seg_32bit; 664146aad74SMarcel Moolenaar desc->sd.sd_gran = ld.limit_in_pages; 665146aad74SMarcel Moolenaar args.op = I386_SET_LDT; 666146aad74SMarcel Moolenaar args.parms = (char*)ldt; 667b40ce416SJulian Elischer error = sysarch(td, &args); 668146aad74SMarcel Moolenaar break; 669146aad74SMarcel Moolenaar default: 670146aad74SMarcel Moolenaar error = EINVAL; 671146aad74SMarcel Moolenaar break; 672146aad74SMarcel Moolenaar } 673146aad74SMarcel Moolenaar 674146aad74SMarcel Moolenaar if (error == EOPNOTSUPP) { 675146aad74SMarcel Moolenaar printf("linux: modify_ldt needs kernel option USER_LDT\n"); 676146aad74SMarcel Moolenaar error = ENOSYS; 677146aad74SMarcel Moolenaar } 678146aad74SMarcel Moolenaar 679146aad74SMarcel Moolenaar return (error); 680146aad74SMarcel Moolenaar } 681146aad74SMarcel Moolenaar 682146aad74SMarcel Moolenaar int 683b40ce416SJulian Elischer linux_sigaction(struct thread *td, struct linux_sigaction_args *args) 684146aad74SMarcel Moolenaar { 6855002a60fSMarcel Moolenaar l_osigaction_t osa; 6865002a60fSMarcel Moolenaar l_sigaction_t act, oact; 687146aad74SMarcel Moolenaar int error; 688146aad74SMarcel Moolenaar 689146aad74SMarcel Moolenaar #ifdef DEBUG 69024593369SJonathan Lemon if (ldebug(sigaction)) 69124593369SJonathan Lemon printf(ARGS(sigaction, "%d, %p, %p"), 692146aad74SMarcel Moolenaar args->sig, (void *)args->nsa, (void *)args->osa); 693146aad74SMarcel Moolenaar #endif 694146aad74SMarcel Moolenaar 695146aad74SMarcel Moolenaar if (args->nsa != NULL) { 6964b7ef73dSDag-Erling Smørgrav error = copyin(args->nsa, &osa, sizeof(l_osigaction_t)); 697146aad74SMarcel Moolenaar if (error) 698146aad74SMarcel Moolenaar return (error); 699146aad74SMarcel Moolenaar act.lsa_handler = osa.lsa_handler; 700146aad74SMarcel Moolenaar act.lsa_flags = osa.lsa_flags; 701146aad74SMarcel Moolenaar act.lsa_restorer = osa.lsa_restorer; 702146aad74SMarcel Moolenaar LINUX_SIGEMPTYSET(act.lsa_mask); 703146aad74SMarcel Moolenaar act.lsa_mask.__bits[0] = osa.lsa_mask; 704146aad74SMarcel Moolenaar } 705146aad74SMarcel Moolenaar 706b40ce416SJulian Elischer error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, 707146aad74SMarcel Moolenaar args->osa ? &oact : NULL); 708146aad74SMarcel Moolenaar 709146aad74SMarcel Moolenaar if (args->osa != NULL && !error) { 710146aad74SMarcel Moolenaar osa.lsa_handler = oact.lsa_handler; 711146aad74SMarcel Moolenaar osa.lsa_flags = oact.lsa_flags; 712146aad74SMarcel Moolenaar osa.lsa_restorer = oact.lsa_restorer; 713146aad74SMarcel Moolenaar osa.lsa_mask = oact.lsa_mask.__bits[0]; 7144b7ef73dSDag-Erling Smørgrav error = copyout(&osa, args->osa, sizeof(l_osigaction_t)); 715146aad74SMarcel Moolenaar } 716146aad74SMarcel Moolenaar 717146aad74SMarcel Moolenaar return (error); 718146aad74SMarcel Moolenaar } 719146aad74SMarcel Moolenaar 720146aad74SMarcel Moolenaar /* 721146aad74SMarcel Moolenaar * Linux has two extra args, restart and oldmask. We dont use these, 722146aad74SMarcel Moolenaar * but it seems that "restart" is actually a context pointer that 723146aad74SMarcel Moolenaar * enables the signal to happen with a different register set. 724146aad74SMarcel Moolenaar */ 725146aad74SMarcel Moolenaar int 726b40ce416SJulian Elischer linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) 727146aad74SMarcel Moolenaar { 728206a5d3aSIan Dowse sigset_t sigmask; 7295002a60fSMarcel Moolenaar l_sigset_t mask; 730146aad74SMarcel Moolenaar 731146aad74SMarcel Moolenaar #ifdef DEBUG 73224593369SJonathan Lemon if (ldebug(sigsuspend)) 73324593369SJonathan Lemon printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask); 734146aad74SMarcel Moolenaar #endif 735146aad74SMarcel Moolenaar 736146aad74SMarcel Moolenaar LINUX_SIGEMPTYSET(mask); 737146aad74SMarcel Moolenaar mask.__bits[0] = args->mask; 738206a5d3aSIan Dowse linux_to_bsd_sigset(&mask, &sigmask); 739206a5d3aSIan Dowse return (kern_sigsuspend(td, sigmask)); 740146aad74SMarcel Moolenaar } 741146aad74SMarcel Moolenaar 742146aad74SMarcel Moolenaar int 743b07cd97eSMark Murray linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap) 744146aad74SMarcel Moolenaar { 7455002a60fSMarcel Moolenaar l_sigset_t lmask; 746206a5d3aSIan Dowse sigset_t sigmask; 747146aad74SMarcel Moolenaar int error; 748146aad74SMarcel Moolenaar 749146aad74SMarcel Moolenaar #ifdef DEBUG 75024593369SJonathan Lemon if (ldebug(rt_sigsuspend)) 75124593369SJonathan Lemon printf(ARGS(rt_sigsuspend, "%p, %d"), 752146aad74SMarcel Moolenaar (void *)uap->newset, uap->sigsetsize); 753146aad74SMarcel Moolenaar #endif 754146aad74SMarcel Moolenaar 7555002a60fSMarcel Moolenaar if (uap->sigsetsize != sizeof(l_sigset_t)) 756146aad74SMarcel Moolenaar return (EINVAL); 757146aad74SMarcel Moolenaar 7585002a60fSMarcel Moolenaar error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); 759146aad74SMarcel Moolenaar if (error) 760146aad74SMarcel Moolenaar return (error); 761146aad74SMarcel Moolenaar 762206a5d3aSIan Dowse linux_to_bsd_sigset(&lmask, &sigmask); 763206a5d3aSIan Dowse return (kern_sigsuspend(td, sigmask)); 764146aad74SMarcel Moolenaar } 765146aad74SMarcel Moolenaar 766146aad74SMarcel Moolenaar int 767b40ce416SJulian Elischer linux_pause(struct thread *td, struct linux_pause_args *args) 768146aad74SMarcel Moolenaar { 769b40ce416SJulian Elischer struct proc *p = td->td_proc; 770206a5d3aSIan Dowse sigset_t sigmask; 771146aad74SMarcel Moolenaar 772146aad74SMarcel Moolenaar #ifdef DEBUG 77324593369SJonathan Lemon if (ldebug(pause)) 77424593369SJonathan Lemon printf(ARGS(pause, "")); 775146aad74SMarcel Moolenaar #endif 776146aad74SMarcel Moolenaar 777fdfdfb78SJohn Baldwin PROC_LOCK(p); 7784093529dSJeff Roberson sigmask = td->td_sigmask; 779fdfdfb78SJohn Baldwin PROC_UNLOCK(p); 780206a5d3aSIan Dowse return (kern_sigsuspend(td, sigmask)); 781146aad74SMarcel Moolenaar } 782146aad74SMarcel Moolenaar 783146aad74SMarcel Moolenaar int 784b40ce416SJulian Elischer linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) 785146aad74SMarcel Moolenaar { 786206a5d3aSIan Dowse stack_t ss, oss; 7875002a60fSMarcel Moolenaar l_stack_t lss; 788146aad74SMarcel Moolenaar int error; 789146aad74SMarcel Moolenaar 790146aad74SMarcel Moolenaar #ifdef DEBUG 79124593369SJonathan Lemon if (ldebug(sigaltstack)) 79224593369SJonathan Lemon printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss); 793146aad74SMarcel Moolenaar #endif 794146aad74SMarcel Moolenaar 795206a5d3aSIan Dowse if (uap->uss != NULL) { 7965002a60fSMarcel Moolenaar error = copyin(uap->uss, &lss, sizeof(l_stack_t)); 797146aad74SMarcel Moolenaar if (error) 798146aad74SMarcel Moolenaar return (error); 799146aad74SMarcel Moolenaar 800206a5d3aSIan Dowse ss.ss_sp = lss.ss_sp; 801206a5d3aSIan Dowse ss.ss_size = lss.ss_size; 802206a5d3aSIan Dowse ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags); 803931a7258SAndrew Gallatin } 804ef36ad69SJohn Baldwin error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL, 805ef36ad69SJohn Baldwin (uap->uoss != NULL) ? &oss : NULL); 806206a5d3aSIan Dowse if (!error && uap->uoss != NULL) { 807206a5d3aSIan Dowse lss.ss_sp = oss.ss_sp; 808206a5d3aSIan Dowse lss.ss_size = oss.ss_size; 809206a5d3aSIan Dowse lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags); 8105002a60fSMarcel Moolenaar error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); 811146aad74SMarcel Moolenaar } 812146aad74SMarcel Moolenaar 813146aad74SMarcel Moolenaar return (error); 814146aad74SMarcel Moolenaar } 8153ad9c842SMaxim Sobolev 8163ad9c842SMaxim Sobolev int 8173ad9c842SMaxim Sobolev linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) 8183ad9c842SMaxim Sobolev { 8193ad9c842SMaxim Sobolev struct ftruncate_args sa; 8203ad9c842SMaxim Sobolev 8213ad9c842SMaxim Sobolev #ifdef DEBUG 8223ad9c842SMaxim Sobolev if (ldebug(ftruncate64)) 823b45bbfc3SBruce Evans printf(ARGS(ftruncate64, "%u, %jd"), args->fd, 824b45bbfc3SBruce Evans (intmax_t)args->length); 8253ad9c842SMaxim Sobolev #endif 8263ad9c842SMaxim Sobolev 8273ad9c842SMaxim Sobolev sa.fd = args->fd; 8283ad9c842SMaxim Sobolev sa.pad = 0; 8293ad9c842SMaxim Sobolev sa.length = args->length; 8303ad9c842SMaxim Sobolev return ftruncate(td, &sa); 8313ad9c842SMaxim Sobolev } 8321bc85c0dSDoug Rabson 8331bc85c0dSDoug Rabson int 8341bc85c0dSDoug Rabson linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args) 8351bc85c0dSDoug Rabson { 8361bc85c0dSDoug Rabson /* 8371bc85c0dSDoug Rabson * Return an error code instead of raising a SIGSYS so that 8381bc85c0dSDoug Rabson * the caller will fall back to simpler LDT methods. 8391bc85c0dSDoug Rabson */ 8401bc85c0dSDoug Rabson return (ENOSYS); 8411bc85c0dSDoug Rabson } 8421bc85c0dSDoug Rabson 8431bc85c0dSDoug Rabson int 8441bc85c0dSDoug Rabson linux_gettid(struct thread *td, struct linux_gettid_args *args) 8451bc85c0dSDoug Rabson { 8461bc85c0dSDoug Rabson 8471bc85c0dSDoug Rabson td->td_retval[0] = td->td_proc->p_pid; 8481bc85c0dSDoug Rabson return (0); 8491bc85c0dSDoug Rabson } 8501bc85c0dSDoug Rabson 8511bc85c0dSDoug Rabson int 8521bc85c0dSDoug Rabson linux_tkill(struct thread *td, struct linux_tkill_args *args) 8531bc85c0dSDoug Rabson { 8541bc85c0dSDoug Rabson 8551bc85c0dSDoug Rabson return (linux_kill(td, (struct linux_kill_args *) args)); 8561bc85c0dSDoug Rabson } 8571bc85c0dSDoug Rabson 858