sys/amd64/linux/linux_machdep.c

   1 /*-
   2  * Copyright (c) 2013 Dmitry Chagin
   3  * Copyright (c) 2004 Tim J. Robbins
   4  * Copyright (c) 2002 Doug Rabson
   5  * Copyright (c) 2000 Marcel Moolenaar
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer
  13  *    in this position and unchanged.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/capsicum.h>
  37 #include <sys/clock.h>
  38 #include <sys/dirent.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/file.h>
  41 #include <sys/filedesc.h>
  42 #include <sys/imgact.h>
  43 #include <sys/kernel.h>
  44 #include <sys/ktr.h>
  45 #include <sys/limits.h>
  46 #include <sys/lock.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mman.h>
  49 #include <sys/mutex.h>
  50 #include <sys/priv.h>
  51 #include <sys/proc.h>
  52 #include <sys/resource.h>
  53 #include <sys/resourcevar.h>
  54 #include <sys/sched.h>
  55 #include <sys/syscallsubr.h>
  56 #include <sys/sysproto.h>
  57 #include <sys/systm.h>
  58 #include <sys/unistd.h>
  59 #include <sys/vnode.h>
  60 #include <sys/wait.h>
  61
  62 #include <security/mac/mac_framework.h>
  63
  64 #include <ufs/ufs/extattr.h>
  65 #include <ufs/ufs/quota.h>
  66 #include <ufs/ufs/ufsmount.h>
  67
  68 #include <machine/frame.h>
  69 #include <machine/md_var.h>
  70 #include <machine/pcb.h>
  71 #include <machine/psl.h>
  72 #include <machine/segments.h>
  73 #include <machine/specialreg.h>
  74
  75 #include <vm/pmap.h>
  76 #include <vm/vm.h>
  77 #include <vm/vm_extern.h>
  78 #include <vm/vm_kern.h>
  79 #include <vm/vm_map.h>
  80
  81 #include <x86/ifunc.h>
  82 #include <x86/sysarch.h>
  83
  84 #include <security/audit/audit.h>
  85
  86 #include <amd64/linux/linux.h>
  87 #include <amd64/linux/linux_proto.h>
  88 #include <compat/linux/linux_emul.h>
  89 #include <compat/linux/linux_file.h>
  90 #include <compat/linux/linux_ipc.h>
  91 #include <compat/linux/linux_misc.h>
  92 #include <compat/linux/linux_mmap.h>
  93 #include <compat/linux/linux_signal.h>
  94 #include <compat/linux/linux_util.h>
  95
  96 int
  97 linux_execve(struct thread *td, struct linux_execve_args *args)
  98 {
  99         struct image_args eargs;
 100         char *path;
 101         int error;
 102
 103         LINUX_CTR(execve);
 104
 105         if (!LUSECONVPATH(td)) {
 106                 error = exec_copyin_args(&eargs, args->path, UIO_USERSPACE,
 107                     args->argp, args->envp);
 108         } else {
 109                 LCONVPATHEXIST(td, args->path, &path);
 110                 error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp,
 111                     args->envp);
 112                 LFREEPATH(path);
 113         }
 114         if (error == 0)
 115                 error = linux_common_execve(td, &eargs);
 116         AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
 117         return (error);
 118 }
 119
 120 int
 121 linux_set_upcall_kse(struct thread *td, register_t stack)
 122 {
 123
 124         if (stack)
 125                 td->td_frame->tf_rsp = stack;
 126
 127         /*
 128          * The newly created Linux thread returns
 129          * to the user space by the same path that a parent does.
 130          */
 131         td->td_frame->tf_rax = 0;
 132         return (0);
 133 }
 134
 135 int
 136 linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
 137 {
 138
 139         return (linux_mmap_common(td, PTROUT(args->addr), args->len, args->prot,
 140                 args->flags, args->fd, args->pgoff));
 141 }
 142
 143 int
 144 linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)
 145 {
 146
 147         return (linux_mprotect_common(td, PTROUT(uap->addr), uap->len, uap->prot));
 148 }
 149
 150 int
 151 linux_madvise(struct thread *td, struct linux_madvise_args *uap)
 152 {
 153
 154         return (linux_madvise_common(td, PTROUT(uap->addr), uap->len, uap->behav));
 155 }
 156
 157 int
 158 linux_iopl(struct thread *td, struct linux_iopl_args *args)
 159 {
 160         int error;
 161
 162         LINUX_CTR(iopl);
 163
 164         if (args->level > 3)
 165                 return (EINVAL);
 166         if ((error = priv_check(td, PRIV_IO)) != 0)
 167                 return (error);
 168         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
 169                 return (error);
 170         td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) |
 171             (args->level * (PSL_IOPL / 3));
 172
 173         return (0);
 174 }
 175
 176 int
 177 linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
 178 {
 179         l_sigset_t lmask;
 180         sigset_t sigmask;
 181         int error;
 182
 183         LINUX_CTR2(rt_sigsuspend, "%p, %ld",
 184             uap->newset, uap->sigsetsize);
 185
 186         if (uap->sigsetsize != sizeof(l_sigset_t))
 187                 return (EINVAL);
 188
 189         error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
 190         if (error)
 191                 return (error);
 192
 193         linux_to_bsd_sigset(&lmask, &sigmask);
 194         return (kern_sigsuspend(td, sigmask));
 195 }
 196
 197 int
 198 linux_pause(struct thread *td, struct linux_pause_args *args)
 199 {
 200         struct proc *p = td->td_proc;
 201         sigset_t sigmask;
 202
 203         LINUX_CTR(pause);
 204
 205         PROC_LOCK(p);
 206         sigmask = td->td_sigmask;
 207         PROC_UNLOCK(p);
 208         return (kern_sigsuspend(td, sigmask));
 209 }
 210
 211 int
 212 linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
 213 {
 214         stack_t ss, oss;
 215         l_stack_t lss;
 216         int error;
 217
 218         memset(&lss, 0, sizeof(lss));
 219         LINUX_CTR2(sigaltstack, "%p, %p", uap->uss, uap->uoss);
 220
 221         if (uap->uss != NULL) {
 222                 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
 223                 if (error)
 224                         return (error);
 225
 226                 ss.ss_sp = PTRIN(lss.ss_sp);
 227                 ss.ss_size = lss.ss_size;
 228                 ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
 229         }
 230         error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
 231             (uap->uoss != NULL) ? &oss : NULL);
 232         if (!error && uap->uoss != NULL) {
 233                 lss.ss_sp = PTROUT(oss.ss_sp);
 234                 lss.ss_size = oss.ss_size;
 235                 lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
 236                 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
 237         }
 238
 239         return (error);
 240 }
 241
 242 int
 243 linux_arch_prctl(struct thread *td, struct linux_arch_prctl_args *args)
 244 {
 245         struct pcb *pcb;
 246         int error;
 247
 248         pcb = td->td_pcb;
 249         LINUX_CTR2(arch_prctl, "0x%x, %p", args->code, args->addr);
 250
 251         switch (args->code) {
 252         case LINUX_ARCH_SET_GS:
 253                 if (args->addr < VM_MAXUSER_ADDRESS) {
 254                         set_pcb_flags(pcb, PCB_FULL_IRET);
 255                         pcb->pcb_gsbase = args->addr;
 256                         td->td_frame->tf_gs = _ugssel;
 257                         error = 0;
 258                 } else
 259                         error = EPERM;
 260                 break;
 261         case LINUX_ARCH_SET_FS:
 262                 if (args->addr < VM_MAXUSER_ADDRESS) {
 263                         set_pcb_flags(pcb, PCB_FULL_IRET);
 264                         pcb->pcb_fsbase = args->addr;
 265                         td->td_frame->tf_fs = _ufssel;
 266                         error = 0;
 267                 } else
 268                         error = EPERM;
 269                 break;
 270         case LINUX_ARCH_GET_FS:
 271                 error = copyout(&pcb->pcb_fsbase, PTRIN(args->addr),
 272                     sizeof(args->addr));
 273                 break;
 274         case LINUX_ARCH_GET_GS:
 275                 error = copyout(&pcb->pcb_gsbase, PTRIN(args->addr),
 276                     sizeof(args->addr));
 277                 break;
 278         default:
 279                 error = EINVAL;
 280         }
 281         return (error);
 282 }
 283
 284 int
 285 linux_set_cloned_tls(struct thread *td, void *desc)
 286 {
 287         struct pcb *pcb;
 288
 289         if ((uint64_t)desc >= VM_MAXUSER_ADDRESS)
 290                 return (EPERM);
 291
 292         pcb = td->td_pcb;
 293         pcb->pcb_fsbase = (register_t)desc;
 294         td->td_frame->tf_fs = _ufssel;
 295
 296         return (0);
 297 }
 298
 299 int futex_xchgl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
 300 int futex_xchgl_smap(int oparg, uint32_t *uaddr, int *oldval);
 301 DEFINE_IFUNC(, int, futex_xchgl, (int, uint32_t *, int *))
 302 {
 303
 304         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
 305             futex_xchgl_smap : futex_xchgl_nosmap);
 306 }
 307
 308 int futex_addl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
 309 int futex_addl_smap(int oparg, uint32_t *uaddr, int *oldval);
 310 DEFINE_IFUNC(, int, futex_addl, (int, uint32_t *, int *))
 311 {
 312
 313         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
 314             futex_addl_smap : futex_addl_nosmap);
 315 }
 316
 317 int futex_orl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
 318 int futex_orl_smap(int oparg, uint32_t *uaddr, int *oldval);
 319 DEFINE_IFUNC(, int, futex_orl, (int, uint32_t *, int *))
 320 {
 321
 322         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
 323             futex_orl_smap : futex_orl_nosmap);
 324 }
 325
 326 int futex_andl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
 327 int futex_andl_smap(int oparg, uint32_t *uaddr, int *oldval);
 328 DEFINE_IFUNC(, int, futex_andl, (int, uint32_t *, int *))
 329 {
 330
 331         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
 332             futex_andl_smap : futex_andl_nosmap);
 333 }
 334
 335 int futex_xorl_nosmap(int oparg, uint32_t *uaddr, int *oldval);
 336 int futex_xorl_smap(int oparg, uint32_t *uaddr, int *oldval);
 337 DEFINE_IFUNC(, int, futex_xorl, (int, uint32_t *, int *))
 338 {
 339
 340         return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ?
 341             futex_xorl_smap : futex_xorl_nosmap);
 342 }