The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/linux/linux_machdep.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2000 Marcel Moolenaar
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer
   10  *    in this position and unchanged.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. The name of the author may not be used to endorse or promote products
   15  *    derived from this software without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/6.0/sys/i386/linux/linux_machdep.c 148711 2005-08-04 23:25:32Z sobomax $");
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 #include <sys/imgact.h>
   35 #include <sys/lock.h>
   36 #include <sys/malloc.h>
   37 #include <sys/mman.h>
   38 #include <sys/mutex.h>
   39 #include <sys/proc.h>
   40 #include <sys/resource.h>
   41 #include <sys/resourcevar.h>
   42 #include <sys/signalvar.h>
   43 #include <sys/syscallsubr.h>
   44 #include <sys/sysproto.h>
   45 #include <sys/unistd.h>
   46 
   47 #include <machine/frame.h>
   48 #include <machine/psl.h>
   49 #include <machine/segments.h>
   50 #include <machine/sysarch.h>
   51 
   52 #include <vm/vm.h>
   53 #include <vm/pmap.h>
   54 #include <vm/vm_map.h>
   55 
   56 #include <i386/linux/linux.h>
   57 #include <i386/linux/linux_proto.h>
   58 #include <compat/linux/linux_ipc.h>
   59 #include <compat/linux/linux_signal.h>
   60 #include <compat/linux/linux_util.h>
   61 
   62 struct l_descriptor {
   63         l_uint          entry_number;
   64         l_ulong         base_addr;
   65         l_uint          limit;
   66         l_uint          seg_32bit:1;
   67         l_uint          contents:2;
   68         l_uint          read_exec_only:1;
   69         l_uint          limit_in_pages:1;
   70         l_uint          seg_not_present:1;
   71         l_uint          useable:1;
   72 };
   73 
   74 struct l_old_select_argv {
   75         l_int           nfds;
   76         l_fd_set        *readfds;
   77         l_fd_set        *writefds;
   78         l_fd_set        *exceptfds;
   79         struct l_timeval        *timeout;
   80 };
   81 
   82 int
   83 linux_to_bsd_sigaltstack(int lsa)
   84 {
   85         int bsa = 0;
   86 
   87         if (lsa & LINUX_SS_DISABLE)
   88                 bsa |= SS_DISABLE;
   89         if (lsa & LINUX_SS_ONSTACK)
   90                 bsa |= SS_ONSTACK;
   91         return (bsa);
   92 }
   93 
   94 int
   95 bsd_to_linux_sigaltstack(int bsa)
   96 {
   97         int lsa = 0;
   98 
   99         if (bsa & SS_DISABLE)
  100                 lsa |= LINUX_SS_DISABLE;
  101         if (bsa & SS_ONSTACK)
  102                 lsa |= LINUX_SS_ONSTACK;
  103         return (lsa);
  104 }
  105 
  106 int
  107 linux_execve(struct thread *td, struct linux_execve_args *args)
  108 {
  109         int error;
  110         char *newpath;
  111         struct image_args eargs;
  112 
  113         LCONVPATHEXIST(td, args->path, &newpath);
  114 
  115 #ifdef DEBUG
  116         if (ldebug(execve))
  117                 printf(ARGS(execve, "%s"), newpath);
  118 #endif
  119 
  120         error = exec_copyin_args(&eargs, newpath, UIO_SYSSPACE,
  121             args->argp, args->envp);
  122         free(newpath, M_TEMP);
  123         if (error == 0)
  124                 error = kern_execve(td, &eargs, NULL);
  125         exec_free_args(&eargs);
  126         return (error);
  127 }
  128 
  129 struct l_ipc_kludge {
  130         struct l_msgbuf *msgp;
  131         l_long msgtyp;
  132 };
  133 
  134 int
  135 linux_ipc(struct thread *td, struct linux_ipc_args *args)
  136 {
  137 
  138         switch (args->what & 0xFFFF) {
  139         case LINUX_SEMOP: {
  140                 struct linux_semop_args a;
  141 
  142                 a.semid = args->arg1;
  143                 a.tsops = args->ptr;
  144                 a.nsops = args->arg2;
  145                 return (linux_semop(td, &a));
  146         }
  147         case LINUX_SEMGET: {
  148                 struct linux_semget_args a;
  149 
  150                 a.key = args->arg1;
  151                 a.nsems = args->arg2;
  152                 a.semflg = args->arg3;
  153                 return (linux_semget(td, &a));
  154         }
  155         case LINUX_SEMCTL: {
  156                 struct linux_semctl_args a;
  157                 int error;
  158 
  159                 a.semid = args->arg1;
  160                 a.semnum = args->arg2;
  161                 a.cmd = args->arg3;
  162                 error = copyin(args->ptr, &a.arg, sizeof(a.arg));
  163                 if (error)
  164                         return (error);
  165                 return (linux_semctl(td, &a));
  166         }
  167         case LINUX_MSGSND: {
  168                 struct linux_msgsnd_args a;
  169 
  170                 a.msqid = args->arg1;
  171                 a.msgp = args->ptr;
  172                 a.msgsz = args->arg2;
  173                 a.msgflg = args->arg3;
  174                 return (linux_msgsnd(td, &a));
  175         }
  176         case LINUX_MSGRCV: {
  177                 struct linux_msgrcv_args a;
  178 
  179                 a.msqid = args->arg1;
  180                 a.msgsz = args->arg2;
  181                 a.msgflg = args->arg3;
  182                 if ((args->what >> 16) == 0) {
  183                         struct l_ipc_kludge tmp;
  184                         int error;
  185 
  186                         if (args->ptr == NULL)
  187                                 return (EINVAL);
  188                         error = copyin(args->ptr, &tmp, sizeof(tmp));
  189                         if (error)
  190                                 return (error);
  191                         a.msgp = tmp.msgp;
  192                         a.msgtyp = tmp.msgtyp;
  193                 } else {
  194                         a.msgp = args->ptr;
  195                         a.msgtyp = args->arg5;
  196                 }
  197                 return (linux_msgrcv(td, &a));
  198         }
  199         case LINUX_MSGGET: {
  200                 struct linux_msgget_args a;
  201 
  202                 a.key = args->arg1;
  203                 a.msgflg = args->arg2;
  204                 return (linux_msgget(td, &a));
  205         }
  206         case LINUX_MSGCTL: {
  207                 struct linux_msgctl_args a;
  208 
  209                 a.msqid = args->arg1;
  210                 a.cmd = args->arg2;
  211                 a.buf = args->ptr;
  212                 return (linux_msgctl(td, &a));
  213         }
  214         case LINUX_SHMAT: {
  215                 struct linux_shmat_args a;
  216 
  217                 a.shmid = args->arg1;
  218                 a.shmaddr = args->ptr;
  219                 a.shmflg = args->arg2;
  220                 a.raddr = (l_ulong *)args->arg3;
  221                 return (linux_shmat(td, &a));
  222         }
  223         case LINUX_SHMDT: {
  224                 struct linux_shmdt_args a;
  225 
  226                 a.shmaddr = args->ptr;
  227                 return (linux_shmdt(td, &a));
  228         }
  229         case LINUX_SHMGET: {
  230                 struct linux_shmget_args a;
  231 
  232                 a.key = args->arg1;
  233                 a.size = args->arg2;
  234                 a.shmflg = args->arg3;
  235                 return (linux_shmget(td, &a));
  236         }
  237         case LINUX_SHMCTL: {
  238                 struct linux_shmctl_args a;
  239 
  240                 a.shmid = args->arg1;
  241                 a.cmd = args->arg2;
  242                 a.buf = args->ptr;
  243                 return (linux_shmctl(td, &a));
  244         }
  245         default:
  246                 break;
  247         }
  248 
  249         return (EINVAL);
  250 }
  251 
  252 int
  253 linux_old_select(struct thread *td, struct linux_old_select_args *args)
  254 {
  255         struct l_old_select_argv linux_args;
  256         struct linux_select_args newsel;
  257         int error;
  258 
  259 #ifdef DEBUG
  260         if (ldebug(old_select))
  261                 printf(ARGS(old_select, "%p"), args->ptr);
  262 #endif
  263 
  264         error = copyin(args->ptr, &linux_args, sizeof(linux_args));
  265         if (error)
  266                 return (error);
  267 
  268         newsel.nfds = linux_args.nfds;
  269         newsel.readfds = linux_args.readfds;
  270         newsel.writefds = linux_args.writefds;
  271         newsel.exceptfds = linux_args.exceptfds;
  272         newsel.timeout = linux_args.timeout;
  273         return (linux_select(td, &newsel));
  274 }
  275 
  276 int
  277 linux_fork(struct thread *td, struct linux_fork_args *args)
  278 {
  279         int error;
  280 
  281 #ifdef DEBUG
  282         if (ldebug(fork))
  283                 printf(ARGS(fork, ""));
  284 #endif
  285 
  286         if ((error = fork(td, (struct fork_args *)args)) != 0)
  287                 return (error);
  288 
  289         if (td->td_retval[1] == 1)
  290                 td->td_retval[0] = 0;
  291         return (0);
  292 }
  293 
  294 int
  295 linux_vfork(struct thread *td, struct linux_vfork_args *args)
  296 {
  297         int error;
  298 
  299 #ifdef DEBUG
  300         if (ldebug(vfork))
  301                 printf(ARGS(vfork, ""));
  302 #endif
  303 
  304         if ((error = vfork(td, (struct vfork_args *)args)) != 0)
  305                 return (error);
  306         /* Are we the child? */
  307         if (td->td_retval[1] == 1)
  308                 td->td_retval[0] = 0;
  309         return (0);
  310 }
  311 
  312 #define CLONE_VM        0x100
  313 #define CLONE_FS        0x200
  314 #define CLONE_FILES     0x400
  315 #define CLONE_SIGHAND   0x800
  316 #define CLONE_PID       0x1000
  317 #define CLONE_THREAD    0x10000
  318 
  319 #define THREADING_FLAGS (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
  320 
  321 int
  322 linux_clone(struct thread *td, struct linux_clone_args *args)
  323 {
  324         int error, ff = RFPROC | RFSTOPPED;
  325         struct proc *p2;
  326         struct thread *td2;
  327         int exit_signal;
  328 
  329 #ifdef DEBUG
  330         if (ldebug(clone)) {
  331                 printf(ARGS(clone, "flags %x, stack %x"),
  332                     (unsigned int)args->flags, (unsigned int)args->stack);
  333                 if (args->flags & CLONE_PID)
  334                         printf(LMSG("CLONE_PID not yet supported"));
  335         }
  336 #endif
  337 
  338         if (!args->stack)
  339                 return (EINVAL);
  340 
  341         exit_signal = args->flags & 0x000000ff;
  342         if (exit_signal >= LINUX_NSIG)
  343                 return (EINVAL);
  344 
  345         if (exit_signal <= LINUX_SIGTBLSZ)
  346                 exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
  347 
  348         if (args->flags & CLONE_VM)
  349                 ff |= RFMEM;
  350         if (args->flags & CLONE_SIGHAND)
  351                 ff |= RFSIGSHARE;
  352         if (!(args->flags & CLONE_FILES))
  353                 ff |= RFFDG;
  354 
  355         /*
  356          * Attempt to detect when linux_clone(2) is used for creating
  357          * kernel threads. Unfortunately despite the existence of the
  358          * CLONE_THREAD flag, version of linuxthreads package used in
  359          * most popular distros as of beginning of 2005 doesn't make
  360          * any use of it. Therefore, this detection relay fully on
  361          * empirical observation that linuxthreads sets certain
  362          * combination of flags, so that we can make more or less
  363          * precise detection and notify the FreeBSD kernel that several
  364          * processes are in fact part of the same threading group, so
  365          * that special treatment is necessary for signal delivery
  366          * between those processes and fd locking.
  367          */
  368         if ((args->flags & 0xffffff00) == THREADING_FLAGS)
  369                 ff |= RFTHREAD;
  370 
  371         error = fork1(td, ff, 0, &p2);
  372         if (error)
  373                 return (error);
  374         
  375 
  376         PROC_LOCK(p2);
  377         p2->p_sigparent = exit_signal;
  378         PROC_UNLOCK(p2);
  379         td2 = FIRST_THREAD_IN_PROC(p2);
  380         td2->td_frame->tf_esp = (unsigned int)args->stack;
  381 
  382 #ifdef DEBUG
  383         if (ldebug(clone))
  384                 printf(LMSG("clone: successful rfork to %ld, stack %p sig = %d"),
  385                     (long)p2->p_pid, args->stack, exit_signal);
  386 #endif
  387 
  388         /*
  389          * Make this runnable after we are finished with it.
  390          */
  391         mtx_lock_spin(&sched_lock);
  392         TD_SET_CAN_RUN(td2);
  393         setrunqueue(td2, SRQ_BORING);
  394         mtx_unlock_spin(&sched_lock);
  395 
  396         td->td_retval[0] = p2->p_pid;
  397         td->td_retval[1] = 0;
  398         return (0);
  399 }
  400 
  401 /* XXX move */
  402 struct l_mmap_argv {
  403         l_caddr_t       addr;
  404         l_int           len;
  405         l_int           prot;
  406         l_int           flags;
  407         l_int           fd;
  408         l_int           pos;
  409 };
  410 
  411 #define STACK_SIZE  (2 * 1024 * 1024)
  412 #define GUARD_SIZE  (4 * PAGE_SIZE)
  413 
  414 static int linux_mmap_common(struct thread *, struct l_mmap_argv *);
  415 
  416 int
  417 linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
  418 {
  419         struct l_mmap_argv linux_args;
  420 
  421 #ifdef DEBUG
  422         if (ldebug(mmap2))
  423                 printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"),
  424                     (void *)args->addr, args->len, args->prot,
  425                     args->flags, args->fd, args->pgoff);
  426 #endif
  427 
  428         linux_args.addr = (l_caddr_t)args->addr;
  429         linux_args.len = args->len;
  430         linux_args.prot = args->prot;
  431         linux_args.flags = args->flags;
  432         linux_args.fd = args->fd;
  433         linux_args.pos = args->pgoff * PAGE_SIZE;
  434 
  435         return (linux_mmap_common(td, &linux_args));
  436 }
  437 
  438 int
  439 linux_mmap(struct thread *td, struct linux_mmap_args *args)
  440 {
  441         int error;
  442         struct l_mmap_argv linux_args;
  443 
  444         error = copyin(args->ptr, &linux_args, sizeof(linux_args));
  445         if (error)
  446                 return (error);
  447 
  448 #ifdef DEBUG
  449         if (ldebug(mmap))
  450                 printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
  451                     (void *)linux_args.addr, linux_args.len, linux_args.prot,
  452                     linux_args.flags, linux_args.fd, linux_args.pos);
  453 #endif
  454 
  455         return (linux_mmap_common(td, &linux_args));
  456 }
  457 
  458 static int
  459 linux_mmap_common(struct thread *td, struct l_mmap_argv *linux_args)
  460 {
  461         struct proc *p = td->td_proc;
  462         struct mmap_args /* {
  463                 caddr_t addr;
  464                 size_t len;
  465                 int prot;
  466                 int flags;
  467                 int fd;
  468                 long pad;
  469                 off_t pos;
  470         } */ bsd_args;
  471         int error;
  472 
  473         error = 0;
  474         bsd_args.flags = 0;
  475         if (linux_args->flags & LINUX_MAP_SHARED)
  476                 bsd_args.flags |= MAP_SHARED;
  477         if (linux_args->flags & LINUX_MAP_PRIVATE)
  478                 bsd_args.flags |= MAP_PRIVATE;
  479         if (linux_args->flags & LINUX_MAP_FIXED)
  480                 bsd_args.flags |= MAP_FIXED;
  481         if (linux_args->flags & LINUX_MAP_ANON)
  482                 bsd_args.flags |= MAP_ANON;
  483         else
  484                 bsd_args.flags |= MAP_NOSYNC;
  485         if (linux_args->flags & LINUX_MAP_GROWSDOWN) {
  486                 bsd_args.flags |= MAP_STACK;
  487 
  488                 /* The linux MAP_GROWSDOWN option does not limit auto
  489                  * growth of the region.  Linux mmap with this option
  490                  * takes as addr the inital BOS, and as len, the initial
  491                  * region size.  It can then grow down from addr without
  492                  * limit.  However, linux threads has an implicit internal
  493                  * limit to stack size of STACK_SIZE.  Its just not
  494                  * enforced explicitly in linux.  But, here we impose
  495                  * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
  496                  * region, since we can do this with our mmap.
  497                  *
  498                  * Our mmap with MAP_STACK takes addr as the maximum
  499                  * downsize limit on BOS, and as len the max size of
  500                  * the region.  It them maps the top SGROWSIZ bytes,
  501                  * and autgrows the region down, up to the limit
  502                  * in addr.
  503                  *
  504                  * If we don't use the MAP_STACK option, the effect
  505                  * of this code is to allocate a stack region of a
  506                  * fixed size of (STACK_SIZE - GUARD_SIZE).
  507                  */
  508 
  509                 /* This gives us TOS */
  510                 bsd_args.addr = linux_args->addr + linux_args->len;
  511 
  512                 if (bsd_args.addr > p->p_vmspace->vm_maxsaddr) {
  513                         /* Some linux apps will attempt to mmap
  514                          * thread stacks near the top of their
  515                          * address space.  If their TOS is greater
  516                          * than vm_maxsaddr, vm_map_growstack()
  517                          * will confuse the thread stack with the
  518                          * process stack and deliver a SEGV if they
  519                          * attempt to grow the thread stack past their
  520                          * current stacksize rlimit.  To avoid this,
  521                          * adjust vm_maxsaddr upwards to reflect
  522                          * the current stacksize rlimit rather
  523                          * than the maximum possible stacksize.
  524                          * It would be better to adjust the
  525                          * mmap'ed region, but some apps do not check
  526                          * mmap's return value.
  527                          */
  528                         PROC_LOCK(p);
  529                         p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
  530                             lim_cur(p, RLIMIT_STACK);
  531                         PROC_UNLOCK(p);
  532                 }
  533 
  534                 /* This gives us our maximum stack size */
  535                 if (linux_args->len > STACK_SIZE - GUARD_SIZE)
  536                         bsd_args.len = linux_args->len;
  537                 else
  538                         bsd_args.len  = STACK_SIZE - GUARD_SIZE;
  539 
  540                 /* This gives us a new BOS.  If we're using VM_STACK, then
  541                  * mmap will just map the top SGROWSIZ bytes, and let
  542                  * the stack grow down to the limit at BOS.  If we're
  543                  * not using VM_STACK we map the full stack, since we
  544                  * don't have a way to autogrow it.
  545                  */
  546                 bsd_args.addr -= bsd_args.len;
  547         } else {
  548                 bsd_args.addr = linux_args->addr;
  549                 bsd_args.len  = linux_args->len;
  550         }
  551 
  552         bsd_args.prot = linux_args->prot | PROT_READ;   /* always required */
  553         if (linux_args->flags & LINUX_MAP_ANON)
  554                 bsd_args.fd = -1;
  555         else
  556                 bsd_args.fd = linux_args->fd;
  557         bsd_args.pos = linux_args->pos;
  558         bsd_args.pad = 0;
  559 
  560 #ifdef DEBUG
  561         if (ldebug(mmap))
  562                 printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n",
  563                     __func__,
  564                     (void *)bsd_args.addr, bsd_args.len, bsd_args.prot,
  565                     bsd_args.flags, bsd_args.fd, (int)bsd_args.pos);
  566 #endif
  567         error = mmap(td, &bsd_args);
  568 #ifdef DEBUG
  569         if (ldebug(mmap))
  570                 printf("-> %s() return: 0x%x (0x%08x)\n",
  571                         __func__, error, (u_int)td->td_retval[0]);
  572 #endif
  573         return (error);
  574 }
  575 
  576 int
  577 linux_pipe(struct thread *td, struct linux_pipe_args *args)
  578 {
  579         int error;
  580         int reg_edx;
  581 
  582 #ifdef DEBUG
  583         if (ldebug(pipe))
  584                 printf(ARGS(pipe, "*"));
  585 #endif
  586 
  587         reg_edx = td->td_retval[1];
  588         error = pipe(td, 0);
  589         if (error) {
  590                 td->td_retval[1] = reg_edx;
  591                 return (error);
  592         }
  593 
  594         error = copyout(td->td_retval, args->pipefds, 2*sizeof(int));
  595         if (error) {
  596                 td->td_retval[1] = reg_edx;
  597                 return (error);
  598         }
  599 
  600         td->td_retval[1] = reg_edx;
  601         td->td_retval[0] = 0;
  602         return (0);
  603 }
  604 
  605 int
  606 linux_ioperm(struct thread *td, struct linux_ioperm_args *args)
  607 {
  608         int error;
  609         struct i386_ioperm_args iia;
  610 
  611         iia.start = args->start;
  612         iia.length = args->length;
  613         iia.enable = args->enable;
  614         mtx_lock(&Giant);
  615         error = i386_set_ioperm(td, &iia);
  616         mtx_unlock(&Giant);
  617         return (error);
  618 }
  619 
  620 int
  621 linux_iopl(struct thread *td, struct linux_iopl_args *args)
  622 {
  623         int error;
  624 
  625         if (args->level < 0 || args->level > 3)
  626                 return (EINVAL);
  627         if ((error = suser(td)) != 0)
  628                 return (error);
  629         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
  630                 return (error);
  631         td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) |
  632             (args->level * (PSL_IOPL / 3));
  633         return (0);
  634 }
  635 
  636 int
  637 linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap)
  638 {
  639         int error;
  640         struct i386_ldt_args ldt;
  641         struct l_descriptor ld;
  642         union descriptor desc;
  643 
  644         if (uap->ptr == NULL)
  645                 return (EINVAL);
  646 
  647         switch (uap->func) {
  648         case 0x00: /* read_ldt */
  649                 ldt.start = 0;
  650                 ldt.descs = uap->ptr;
  651                 ldt.num = uap->bytecount / sizeof(union descriptor);
  652                 mtx_lock(&Giant);
  653                 error = i386_get_ldt(td, &ldt);
  654                 td->td_retval[0] *= sizeof(union descriptor);
  655                 mtx_unlock(&Giant);
  656                 break;
  657         case 0x01: /* write_ldt */
  658         case 0x11: /* write_ldt */
  659                 if (uap->bytecount != sizeof(ld))
  660                         return (EINVAL);
  661 
  662                 error = copyin(uap->ptr, &ld, sizeof(ld));
  663                 if (error)
  664                         return (error);
  665 
  666                 ldt.start = ld.entry_number;
  667                 ldt.descs = &desc;
  668                 ldt.num = 1;
  669                 desc.sd.sd_lolimit = (ld.limit & 0x0000ffff);
  670                 desc.sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16;
  671                 desc.sd.sd_lobase = (ld.base_addr & 0x00ffffff);
  672                 desc.sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24;
  673                 desc.sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) |
  674                         (ld.contents << 2);
  675                 desc.sd.sd_dpl = 3;
  676                 desc.sd.sd_p = (ld.seg_not_present ^ 1);
  677                 desc.sd.sd_xx = 0;
  678                 desc.sd.sd_def32 = ld.seg_32bit;
  679                 desc.sd.sd_gran = ld.limit_in_pages;
  680                 mtx_lock(&Giant);
  681                 error = i386_set_ldt(td, &ldt, &desc);
  682                 mtx_unlock(&Giant);
  683                 break;
  684         default:
  685                 error = EINVAL;
  686                 break;
  687         }
  688 
  689         if (error == EOPNOTSUPP) {
  690                 printf("linux: modify_ldt needs kernel option USER_LDT\n");
  691                 error = ENOSYS;
  692         }
  693 
  694         return (error);
  695 }
  696 
  697 int
  698 linux_sigaction(struct thread *td, struct linux_sigaction_args *args)
  699 {
  700         l_osigaction_t osa;
  701         l_sigaction_t act, oact;
  702         int error;
  703 
  704 #ifdef DEBUG
  705         if (ldebug(sigaction))
  706                 printf(ARGS(sigaction, "%d, %p, %p"),
  707                     args->sig, (void *)args->nsa, (void *)args->osa);
  708 #endif
  709 
  710         if (args->nsa != NULL) {
  711                 error = copyin(args->nsa, &osa, sizeof(l_osigaction_t));
  712                 if (error)
  713                         return (error);
  714                 act.lsa_handler = osa.lsa_handler;
  715                 act.lsa_flags = osa.lsa_flags;
  716                 act.lsa_restorer = osa.lsa_restorer;
  717                 LINUX_SIGEMPTYSET(act.lsa_mask);
  718                 act.lsa_mask.__bits[0] = osa.lsa_mask;
  719         }
  720 
  721         error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL,
  722             args->osa ? &oact : NULL);
  723 
  724         if (args->osa != NULL && !error) {
  725                 osa.lsa_handler = oact.lsa_handler;
  726                 osa.lsa_flags = oact.lsa_flags;
  727                 osa.lsa_restorer = oact.lsa_restorer;
  728                 osa.lsa_mask = oact.lsa_mask.__bits[0];
  729                 error = copyout(&osa, args->osa, sizeof(l_osigaction_t));
  730         }
  731 
  732         return (error);
  733 }
  734 
  735 /*
  736  * Linux has two extra args, restart and oldmask.  We dont use these,
  737  * but it seems that "restart" is actually a context pointer that
  738  * enables the signal to happen with a different register set.
  739  */
  740 int
  741 linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args)
  742 {
  743         sigset_t sigmask;
  744         l_sigset_t mask;
  745 
  746 #ifdef DEBUG
  747         if (ldebug(sigsuspend))
  748                 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
  749 #endif
  750 
  751         LINUX_SIGEMPTYSET(mask);
  752         mask.__bits[0] = args->mask;
  753         linux_to_bsd_sigset(&mask, &sigmask);
  754         return (kern_sigsuspend(td, sigmask));
  755 }
  756 
  757 int
  758 linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
  759 {
  760         l_sigset_t lmask;
  761         sigset_t sigmask;
  762         int error;
  763 
  764 #ifdef DEBUG
  765         if (ldebug(rt_sigsuspend))
  766                 printf(ARGS(rt_sigsuspend, "%p, %d"),
  767                     (void *)uap->newset, uap->sigsetsize);
  768 #endif
  769 
  770         if (uap->sigsetsize != sizeof(l_sigset_t))
  771                 return (EINVAL);
  772 
  773         error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
  774         if (error)
  775                 return (error);
  776 
  777         linux_to_bsd_sigset(&lmask, &sigmask);
  778         return (kern_sigsuspend(td, sigmask));
  779 }
  780 
  781 int
  782 linux_pause(struct thread *td, struct linux_pause_args *args)
  783 {
  784         struct proc *p = td->td_proc;
  785         sigset_t sigmask;
  786 
  787 #ifdef DEBUG
  788         if (ldebug(pause))
  789                 printf(ARGS(pause, ""));
  790 #endif
  791 
  792         PROC_LOCK(p);
  793         sigmask = td->td_sigmask;
  794         PROC_UNLOCK(p);
  795         return (kern_sigsuspend(td, sigmask));
  796 }
  797 
  798 int
  799 linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
  800 {
  801         stack_t ss, oss;
  802         l_stack_t lss;
  803         int error;
  804 
  805 #ifdef DEBUG
  806         if (ldebug(sigaltstack))
  807                 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
  808 #endif
  809 
  810         if (uap->uss != NULL) {
  811                 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
  812                 if (error)
  813                         return (error);
  814 
  815                 ss.ss_sp = lss.ss_sp;
  816                 ss.ss_size = lss.ss_size;
  817                 ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
  818         }
  819         error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
  820             (uap->uoss != NULL) ? &oss : NULL);
  821         if (!error && uap->uoss != NULL) {
  822                 lss.ss_sp = oss.ss_sp;
  823                 lss.ss_size = oss.ss_size;
  824                 lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
  825                 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
  826         }
  827 
  828         return (error);
  829 }
  830 
  831 int
  832 linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
  833 {
  834         struct ftruncate_args sa;
  835 
  836 #ifdef DEBUG
  837         if (ldebug(ftruncate64))
  838                 printf(ARGS(ftruncate64, "%u, %jd"), args->fd,
  839                     (intmax_t)args->length);
  840 #endif
  841 
  842         sa.fd = args->fd;
  843         sa.pad = 0;
  844         sa.length = args->length;
  845         return ftruncate(td, &sa);
  846 }
  847 
  848 int
  849 linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args)
  850 {
  851         /*
  852          * Return an error code instead of raising a SIGSYS so that
  853          * the caller will fall back to simpler LDT methods.
  854          */
  855         return (ENOSYS);
  856 }
  857 
  858 int
  859 linux_gettid(struct thread *td, struct linux_gettid_args *args)
  860 {
  861 
  862         td->td_retval[0] = td->td_proc->p_pid;
  863         return (0);
  864 }
  865 
  866 int
  867 linux_tkill(struct thread *td, struct linux_tkill_args *args)
  868 {
  869 
  870         return (linux_kill(td, (struct linux_kill_args *) args));
  871 }
  872 

Cache object: eaa29888dbf90f106950fab20dc8587d


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.