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/compat/linux/linux_misc.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2002 Doug Rabson
    3  * Copyright (c) 1994-1995 Søren Schmidt
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer
   11  *    in this position and unchanged.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. The name of the author may not be used to endorse or promote products
   16  *    derived from this software without specific prior written permission
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: releng/11.0/sys/compat/linux/linux_misc.c 303005 2016-07-18 16:34:11Z dchagin $");
   32 
   33 #include "opt_compat.h"
   34 
   35 #include <sys/param.h>
   36 #include <sys/blist.h>
   37 #include <sys/fcntl.h>
   38 #if defined(__i386__)
   39 #include <sys/imgact_aout.h>
   40 #endif
   41 #include <sys/jail.h>
   42 #include <sys/kernel.h>
   43 #include <sys/limits.h>
   44 #include <sys/lock.h>
   45 #include <sys/malloc.h>
   46 #include <sys/mman.h>
   47 #include <sys/mount.h>
   48 #include <sys/mutex.h>
   49 #include <sys/namei.h>
   50 #include <sys/priv.h>
   51 #include <sys/proc.h>
   52 #include <sys/reboot.h>
   53 #include <sys/racct.h>
   54 #include <sys/resourcevar.h>
   55 #include <sys/sched.h>
   56 #include <sys/sdt.h>
   57 #include <sys/signalvar.h>
   58 #include <sys/stat.h>
   59 #include <sys/syscallsubr.h>
   60 #include <sys/sysctl.h>
   61 #include <sys/sysproto.h>
   62 #include <sys/systm.h>
   63 #include <sys/time.h>
   64 #include <sys/vmmeter.h>
   65 #include <sys/vnode.h>
   66 #include <sys/wait.h>
   67 #include <sys/cpuset.h>
   68 
   69 #include <security/mac/mac_framework.h>
   70 
   71 #include <vm/vm.h>
   72 #include <vm/pmap.h>
   73 #include <vm/vm_kern.h>
   74 #include <vm/vm_map.h>
   75 #include <vm/vm_extern.h>
   76 #include <vm/vm_object.h>
   77 #include <vm/swap_pager.h>
   78 
   79 #ifdef COMPAT_LINUX32
   80 #include <machine/../linux32/linux.h>
   81 #include <machine/../linux32/linux32_proto.h>
   82 #else
   83 #include <machine/../linux/linux.h>
   84 #include <machine/../linux/linux_proto.h>
   85 #endif
   86 
   87 #include <compat/linux/linux_dtrace.h>
   88 #include <compat/linux/linux_file.h>
   89 #include <compat/linux/linux_mib.h>
   90 #include <compat/linux/linux_signal.h>
   91 #include <compat/linux/linux_timer.h>
   92 #include <compat/linux/linux_util.h>
   93 #include <compat/linux/linux_sysproto.h>
   94 #include <compat/linux/linux_emul.h>
   95 #include <compat/linux/linux_misc.h>
   96 
   97 /**
   98  * Special DTrace provider for the linuxulator.
   99  *
  100  * In this file we define the provider for the entire linuxulator. All
  101  * modules (= files of the linuxulator) use it.
  102  *
  103  * We define a different name depending on the emulated bitsize, see
  104  * ../../<ARCH>/linux{,32}/linux.h, e.g.:
  105  *      native bitsize          = linuxulator
  106  *      amd64, 32bit emulation  = linuxulator32
  107  */
  108 LIN_SDT_PROVIDER_DEFINE(LINUX_DTRACE);
  109 
  110 int stclohz;                            /* Statistics clock frequency */
  111 
  112 static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = {
  113         RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK,
  114         RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE,
  115         RLIMIT_MEMLOCK, RLIMIT_AS 
  116 };
  117 
  118 struct l_sysinfo {
  119         l_long          uptime;         /* Seconds since boot */
  120         l_ulong         loads[3];       /* 1, 5, and 15 minute load averages */
  121 #define LINUX_SYSINFO_LOADS_SCALE 65536
  122         l_ulong         totalram;       /* Total usable main memory size */
  123         l_ulong         freeram;        /* Available memory size */
  124         l_ulong         sharedram;      /* Amount of shared memory */
  125         l_ulong         bufferram;      /* Memory used by buffers */
  126         l_ulong         totalswap;      /* Total swap space size */
  127         l_ulong         freeswap;       /* swap space still available */
  128         l_ushort        procs;          /* Number of current processes */
  129         l_ushort        pads;
  130         l_ulong         totalbig;
  131         l_ulong         freebig;
  132         l_uint          mem_unit;
  133         char            _f[20-2*sizeof(l_long)-sizeof(l_int)];  /* padding */
  134 };
  135 
  136 struct l_pselect6arg {
  137         l_uintptr_t     ss;
  138         l_size_t        ss_len;
  139 };
  140 
  141 static int      linux_utimensat_nsec_valid(l_long);
  142 
  143 
  144 int
  145 linux_sysinfo(struct thread *td, struct linux_sysinfo_args *args)
  146 {
  147         struct l_sysinfo sysinfo;
  148         vm_object_t object;
  149         int i, j;
  150         struct timespec ts;
  151 
  152         bzero(&sysinfo, sizeof(sysinfo));
  153         getnanouptime(&ts);
  154         if (ts.tv_nsec != 0)
  155                 ts.tv_sec++;
  156         sysinfo.uptime = ts.tv_sec;
  157 
  158         /* Use the information from the mib to get our load averages */
  159         for (i = 0; i < 3; i++)
  160                 sysinfo.loads[i] = averunnable.ldavg[i] *
  161                     LINUX_SYSINFO_LOADS_SCALE / averunnable.fscale;
  162 
  163         sysinfo.totalram = physmem * PAGE_SIZE;
  164         sysinfo.freeram = sysinfo.totalram - vm_cnt.v_wire_count * PAGE_SIZE;
  165 
  166         sysinfo.sharedram = 0;
  167         mtx_lock(&vm_object_list_mtx);
  168         TAILQ_FOREACH(object, &vm_object_list, object_list)
  169                 if (object->shadow_count > 1)
  170                         sysinfo.sharedram += object->resident_page_count;
  171         mtx_unlock(&vm_object_list_mtx);
  172 
  173         sysinfo.sharedram *= PAGE_SIZE;
  174         sysinfo.bufferram = 0;
  175 
  176         swap_pager_status(&i, &j);
  177         sysinfo.totalswap = i * PAGE_SIZE;
  178         sysinfo.freeswap = (i - j) * PAGE_SIZE;
  179 
  180         sysinfo.procs = nprocs;
  181 
  182         /* The following are only present in newer Linux kernels. */
  183         sysinfo.totalbig = 0;
  184         sysinfo.freebig = 0;
  185         sysinfo.mem_unit = 1;
  186 
  187         return (copyout(&sysinfo, args->info, sizeof(sysinfo)));
  188 }
  189 
  190 int
  191 linux_alarm(struct thread *td, struct linux_alarm_args *args)
  192 {
  193         struct itimerval it, old_it;
  194         u_int secs;
  195         int error;
  196 
  197 #ifdef DEBUG
  198         if (ldebug(alarm))
  199                 printf(ARGS(alarm, "%u"), args->secs);
  200 #endif
  201         secs = args->secs;
  202         /*
  203          * Linux alarm() is always successful. Limit secs to INT32_MAX / 2
  204          * to match kern_setitimer()'s limit to avoid error from it.
  205          *
  206          * XXX. Linux limit secs to INT_MAX on 32 and does not limit on 64-bit
  207          * platforms.
  208          */
  209         if (secs > INT32_MAX / 2)
  210                 secs = INT32_MAX / 2;
  211 
  212         it.it_value.tv_sec = secs;
  213         it.it_value.tv_usec = 0;
  214         timevalclear(&it.it_interval);
  215         error = kern_setitimer(td, ITIMER_REAL, &it, &old_it);
  216         KASSERT(error == 0, ("kern_setitimer returns %d", error));
  217 
  218         if ((old_it.it_value.tv_sec == 0 && old_it.it_value.tv_usec > 0) ||
  219             old_it.it_value.tv_usec >= 500000)
  220                 old_it.it_value.tv_sec++;
  221         td->td_retval[0] = old_it.it_value.tv_sec;
  222         return (0);
  223 }
  224 
  225 int
  226 linux_brk(struct thread *td, struct linux_brk_args *args)
  227 {
  228         struct vmspace *vm = td->td_proc->p_vmspace;
  229         vm_offset_t new, old;
  230         struct obreak_args /* {
  231                 char * nsize;
  232         } */ tmp;
  233 
  234 #ifdef DEBUG
  235         if (ldebug(brk))
  236                 printf(ARGS(brk, "%p"), (void *)(uintptr_t)args->dsend);
  237 #endif
  238         old = (vm_offset_t)vm->vm_daddr + ctob(vm->vm_dsize);
  239         new = (vm_offset_t)args->dsend;
  240         tmp.nsize = (char *)new;
  241         if (((caddr_t)new > vm->vm_daddr) && !sys_obreak(td, &tmp))
  242                 td->td_retval[0] = (long)new;
  243         else
  244                 td->td_retval[0] = (long)old;
  245 
  246         return (0);
  247 }
  248 
  249 #if defined(__i386__)
  250 /* XXX: what about amd64/linux32? */
  251 
  252 int
  253 linux_uselib(struct thread *td, struct linux_uselib_args *args)
  254 {
  255         struct nameidata ni;
  256         struct vnode *vp;
  257         struct exec *a_out;
  258         struct vattr attr;
  259         vm_offset_t vmaddr;
  260         unsigned long file_offset;
  261         unsigned long bss_size;
  262         char *library;
  263         ssize_t aresid;
  264         int error, locked, writecount;
  265 
  266         LCONVPATHEXIST(td, args->library, &library);
  267 
  268 #ifdef DEBUG
  269         if (ldebug(uselib))
  270                 printf(ARGS(uselib, "%s"), library);
  271 #endif
  272 
  273         a_out = NULL;
  274         locked = 0;
  275         vp = NULL;
  276 
  277         NDINIT(&ni, LOOKUP, ISOPEN | FOLLOW | LOCKLEAF | AUDITVNODE1,
  278             UIO_SYSSPACE, library, td);
  279         error = namei(&ni);
  280         LFREEPATH(library);
  281         if (error)
  282                 goto cleanup;
  283 
  284         vp = ni.ni_vp;
  285         NDFREE(&ni, NDF_ONLY_PNBUF);
  286 
  287         /*
  288          * From here on down, we have a locked vnode that must be unlocked.
  289          * XXX: The code below largely duplicates exec_check_permissions().
  290          */
  291         locked = 1;
  292 
  293         /* Writable? */
  294         error = VOP_GET_WRITECOUNT(vp, &writecount);
  295         if (error != 0)
  296                 goto cleanup;
  297         if (writecount != 0) {
  298                 error = ETXTBSY;
  299                 goto cleanup;
  300         }
  301 
  302         /* Executable? */
  303         error = VOP_GETATTR(vp, &attr, td->td_ucred);
  304         if (error)
  305                 goto cleanup;
  306 
  307         if ((vp->v_mount->mnt_flag & MNT_NOEXEC) ||
  308             ((attr.va_mode & 0111) == 0) || (attr.va_type != VREG)) {
  309                 /* EACCESS is what exec(2) returns. */
  310                 error = ENOEXEC;
  311                 goto cleanup;
  312         }
  313 
  314         /* Sensible size? */
  315         if (attr.va_size == 0) {
  316                 error = ENOEXEC;
  317                 goto cleanup;
  318         }
  319 
  320         /* Can we access it? */
  321         error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
  322         if (error)
  323                 goto cleanup;
  324 
  325         /*
  326          * XXX: This should use vn_open() so that it is properly authorized,
  327          * and to reduce code redundancy all over the place here.
  328          * XXX: Not really, it duplicates far more of exec_check_permissions()
  329          * than vn_open().
  330          */
  331 #ifdef MAC
  332         error = mac_vnode_check_open(td->td_ucred, vp, VREAD);
  333         if (error)
  334                 goto cleanup;
  335 #endif
  336         error = VOP_OPEN(vp, FREAD, td->td_ucred, td, NULL);
  337         if (error)
  338                 goto cleanup;
  339 
  340         /* Pull in executable header into exec_map */
  341         error = vm_mmap(exec_map, (vm_offset_t *)&a_out, PAGE_SIZE,
  342             VM_PROT_READ, VM_PROT_READ, 0, OBJT_VNODE, vp, 0);
  343         if (error)
  344                 goto cleanup;
  345 
  346         /* Is it a Linux binary ? */
  347         if (((a_out->a_magic >> 16) & 0xff) != 0x64) {
  348                 error = ENOEXEC;
  349                 goto cleanup;
  350         }
  351 
  352         /*
  353          * While we are here, we should REALLY do some more checks
  354          */
  355 
  356         /* Set file/virtual offset based on a.out variant. */
  357         switch ((int)(a_out->a_magic & 0xffff)) {
  358         case 0413:                      /* ZMAGIC */
  359                 file_offset = 1024;
  360                 break;
  361         case 0314:                      /* QMAGIC */
  362                 file_offset = 0;
  363                 break;
  364         default:
  365                 error = ENOEXEC;
  366                 goto cleanup;
  367         }
  368 
  369         bss_size = round_page(a_out->a_bss);
  370 
  371         /* Check various fields in header for validity/bounds. */
  372         if (a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK) {
  373                 error = ENOEXEC;
  374                 goto cleanup;
  375         }
  376 
  377         /* text + data can't exceed file size */
  378         if (a_out->a_data + a_out->a_text > attr.va_size) {
  379                 error = EFAULT;
  380                 goto cleanup;
  381         }
  382 
  383         /*
  384          * text/data/bss must not exceed limits
  385          * XXX - this is not complete. it should check current usage PLUS
  386          * the resources needed by this library.
  387          */
  388         PROC_LOCK(td->td_proc);
  389         if (a_out->a_text > maxtsiz ||
  390             a_out->a_data + bss_size > lim_cur_proc(td->td_proc, RLIMIT_DATA) ||
  391             racct_set(td->td_proc, RACCT_DATA, a_out->a_data +
  392             bss_size) != 0) {
  393                 PROC_UNLOCK(td->td_proc);
  394                 error = ENOMEM;
  395                 goto cleanup;
  396         }
  397         PROC_UNLOCK(td->td_proc);
  398 
  399         /*
  400          * Prevent more writers.
  401          * XXX: Note that if any of the VM operations fail below we don't
  402          * clear this flag.
  403          */
  404         VOP_SET_TEXT(vp);
  405 
  406         /*
  407          * Lock no longer needed
  408          */
  409         locked = 0;
  410         VOP_UNLOCK(vp, 0);
  411 
  412         /*
  413          * Check if file_offset page aligned. Currently we cannot handle
  414          * misalinged file offsets, and so we read in the entire image
  415          * (what a waste).
  416          */
  417         if (file_offset & PAGE_MASK) {
  418 #ifdef DEBUG
  419                 printf("uselib: Non page aligned binary %lu\n", file_offset);
  420 #endif
  421                 /* Map text+data read/write/execute */
  422 
  423                 /* a_entry is the load address and is page aligned */
  424                 vmaddr = trunc_page(a_out->a_entry);
  425 
  426                 /* get anon user mapping, read+write+execute */
  427                 error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0,
  428                     &vmaddr, a_out->a_text + a_out->a_data, 0, VMFS_NO_SPACE,
  429                     VM_PROT_ALL, VM_PROT_ALL, 0);
  430                 if (error)
  431                         goto cleanup;
  432 
  433                 error = vn_rdwr(UIO_READ, vp, (void *)vmaddr, file_offset,
  434                     a_out->a_text + a_out->a_data, UIO_USERSPACE, 0,
  435                     td->td_ucred, NOCRED, &aresid, td);
  436                 if (error != 0)
  437                         goto cleanup;
  438                 if (aresid != 0) {
  439                         error = ENOEXEC;
  440                         goto cleanup;
  441                 }
  442         } else {
  443 #ifdef DEBUG
  444                 printf("uselib: Page aligned binary %lu\n", file_offset);
  445 #endif
  446                 /*
  447                  * for QMAGIC, a_entry is 20 bytes beyond the load address
  448                  * to skip the executable header
  449                  */
  450                 vmaddr = trunc_page(a_out->a_entry);
  451 
  452                 /*
  453                  * Map it all into the process's space as a single
  454                  * copy-on-write "data" segment.
  455                  */
  456                 error = vm_mmap(&td->td_proc->p_vmspace->vm_map, &vmaddr,
  457                     a_out->a_text + a_out->a_data, VM_PROT_ALL, VM_PROT_ALL,
  458                     MAP_PRIVATE | MAP_FIXED, OBJT_VNODE, vp, file_offset);
  459                 if (error)
  460                         goto cleanup;
  461         }
  462 #ifdef DEBUG
  463         printf("mem=%08lx = %08lx %08lx\n", (long)vmaddr, ((long *)vmaddr)[0],
  464             ((long *)vmaddr)[1]);
  465 #endif
  466         if (bss_size != 0) {
  467                 /* Calculate BSS start address */
  468                 vmaddr = trunc_page(a_out->a_entry) + a_out->a_text +
  469                     a_out->a_data;
  470 
  471                 /* allocate some 'anon' space */
  472                 error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0,
  473                     &vmaddr, bss_size, 0, VMFS_NO_SPACE, VM_PROT_ALL,
  474                     VM_PROT_ALL, 0);
  475                 if (error)
  476                         goto cleanup;
  477         }
  478 
  479 cleanup:
  480         /* Unlock vnode if needed */
  481         if (locked)
  482                 VOP_UNLOCK(vp, 0);
  483 
  484         /* Release the temporary mapping. */
  485         if (a_out)
  486                 kmap_free_wakeup(exec_map, (vm_offset_t)a_out, PAGE_SIZE);
  487 
  488         return (error);
  489 }
  490 
  491 #endif  /* __i386__ */
  492 
  493 int
  494 linux_select(struct thread *td, struct linux_select_args *args)
  495 {
  496         l_timeval ltv;
  497         struct timeval tv0, tv1, utv, *tvp;
  498         int error;
  499 
  500 #ifdef DEBUG
  501         if (ldebug(select))
  502                 printf(ARGS(select, "%d, %p, %p, %p, %p"), args->nfds,
  503                     (void *)args->readfds, (void *)args->writefds,
  504                     (void *)args->exceptfds, (void *)args->timeout);
  505 #endif
  506 
  507         /*
  508          * Store current time for computation of the amount of
  509          * time left.
  510          */
  511         if (args->timeout) {
  512                 if ((error = copyin(args->timeout, &ltv, sizeof(ltv))))
  513                         goto select_out;
  514                 utv.tv_sec = ltv.tv_sec;
  515                 utv.tv_usec = ltv.tv_usec;
  516 #ifdef DEBUG
  517                 if (ldebug(select))
  518                         printf(LMSG("incoming timeout (%jd/%ld)"),
  519                             (intmax_t)utv.tv_sec, utv.tv_usec);
  520 #endif
  521 
  522                 if (itimerfix(&utv)) {
  523                         /*
  524                          * The timeval was invalid.  Convert it to something
  525                          * valid that will act as it does under Linux.
  526                          */
  527                         utv.tv_sec += utv.tv_usec / 1000000;
  528                         utv.tv_usec %= 1000000;
  529                         if (utv.tv_usec < 0) {
  530                                 utv.tv_sec -= 1;
  531                                 utv.tv_usec += 1000000;
  532                         }
  533                         if (utv.tv_sec < 0)
  534                                 timevalclear(&utv);
  535                 }
  536                 microtime(&tv0);
  537                 tvp = &utv;
  538         } else
  539                 tvp = NULL;
  540 
  541         error = kern_select(td, args->nfds, args->readfds, args->writefds,
  542             args->exceptfds, tvp, LINUX_NFDBITS);
  543 
  544 #ifdef DEBUG
  545         if (ldebug(select))
  546                 printf(LMSG("real select returns %d"), error);
  547 #endif
  548         if (error)
  549                 goto select_out;
  550 
  551         if (args->timeout) {
  552                 if (td->td_retval[0]) {
  553                         /*
  554                          * Compute how much time was left of the timeout,
  555                          * by subtracting the current time and the time
  556                          * before we started the call, and subtracting
  557                          * that result from the user-supplied value.
  558                          */
  559                         microtime(&tv1);
  560                         timevalsub(&tv1, &tv0);
  561                         timevalsub(&utv, &tv1);
  562                         if (utv.tv_sec < 0)
  563                                 timevalclear(&utv);
  564                 } else
  565                         timevalclear(&utv);
  566 #ifdef DEBUG
  567                 if (ldebug(select))
  568                         printf(LMSG("outgoing timeout (%jd/%ld)"),
  569                             (intmax_t)utv.tv_sec, utv.tv_usec);
  570 #endif
  571                 ltv.tv_sec = utv.tv_sec;
  572                 ltv.tv_usec = utv.tv_usec;
  573                 if ((error = copyout(&ltv, args->timeout, sizeof(ltv))))
  574                         goto select_out;
  575         }
  576 
  577 select_out:
  578 #ifdef DEBUG
  579         if (ldebug(select))
  580                 printf(LMSG("select_out -> %d"), error);
  581 #endif
  582         return (error);
  583 }
  584 
  585 int
  586 linux_mremap(struct thread *td, struct linux_mremap_args *args)
  587 {
  588         struct munmap_args /* {
  589                 void *addr;
  590                 size_t len;
  591         } */ bsd_args;
  592         int error = 0;
  593 
  594 #ifdef DEBUG
  595         if (ldebug(mremap))
  596                 printf(ARGS(mremap, "%p, %08lx, %08lx, %08lx"),
  597                     (void *)(uintptr_t)args->addr,
  598                     (unsigned long)args->old_len,
  599                     (unsigned long)args->new_len,
  600                     (unsigned long)args->flags);
  601 #endif
  602 
  603         if (args->flags & ~(LINUX_MREMAP_FIXED | LINUX_MREMAP_MAYMOVE)) {
  604                 td->td_retval[0] = 0;
  605                 return (EINVAL);
  606         }
  607 
  608         /*
  609          * Check for the page alignment.
  610          * Linux defines PAGE_MASK to be FreeBSD ~PAGE_MASK.
  611          */
  612         if (args->addr & PAGE_MASK) {
  613                 td->td_retval[0] = 0;
  614                 return (EINVAL);
  615         }
  616 
  617         args->new_len = round_page(args->new_len);
  618         args->old_len = round_page(args->old_len);
  619 
  620         if (args->new_len > args->old_len) {
  621                 td->td_retval[0] = 0;
  622                 return (ENOMEM);
  623         }
  624 
  625         if (args->new_len < args->old_len) {
  626                 bsd_args.addr =
  627                     (caddr_t)((uintptr_t)args->addr + args->new_len);
  628                 bsd_args.len = args->old_len - args->new_len;
  629                 error = sys_munmap(td, &bsd_args);
  630         }
  631 
  632         td->td_retval[0] = error ? 0 : (uintptr_t)args->addr;
  633         return (error);
  634 }
  635 
  636 #define LINUX_MS_ASYNC       0x0001
  637 #define LINUX_MS_INVALIDATE  0x0002
  638 #define LINUX_MS_SYNC        0x0004
  639 
  640 int
  641 linux_msync(struct thread *td, struct linux_msync_args *args)
  642 {
  643         struct msync_args bsd_args;
  644 
  645         bsd_args.addr = (caddr_t)(uintptr_t)args->addr;
  646         bsd_args.len = (uintptr_t)args->len;
  647         bsd_args.flags = args->fl & ~LINUX_MS_SYNC;
  648 
  649         return (sys_msync(td, &bsd_args));
  650 }
  651 
  652 int
  653 linux_time(struct thread *td, struct linux_time_args *args)
  654 {
  655         struct timeval tv;
  656         l_time_t tm;
  657         int error;
  658 
  659 #ifdef DEBUG
  660         if (ldebug(time))
  661                 printf(ARGS(time, "*"));
  662 #endif
  663 
  664         microtime(&tv);
  665         tm = tv.tv_sec;
  666         if (args->tm && (error = copyout(&tm, args->tm, sizeof(tm))))
  667                 return (error);
  668         td->td_retval[0] = tm;
  669         return (0);
  670 }
  671 
  672 struct l_times_argv {
  673         l_clock_t       tms_utime;
  674         l_clock_t       tms_stime;
  675         l_clock_t       tms_cutime;
  676         l_clock_t       tms_cstime;
  677 };
  678 
  679 
  680 /*
  681  * Glibc versions prior to 2.2.1 always use hard-coded CLK_TCK value.
  682  * Since 2.2.1 Glibc uses value exported from kernel via AT_CLKTCK
  683  * auxiliary vector entry.
  684  */
  685 #define CLK_TCK         100
  686 
  687 #define CONVOTCK(r)     (r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK))
  688 #define CONVNTCK(r)     (r.tv_sec * stclohz + r.tv_usec / (1000000 / stclohz))
  689 
  690 #define CONVTCK(r)      (linux_kernver(td) >= LINUX_KERNVER_2004000 ?           \
  691                             CONVNTCK(r) : CONVOTCK(r))
  692 
  693 int
  694 linux_times(struct thread *td, struct linux_times_args *args)
  695 {
  696         struct timeval tv, utime, stime, cutime, cstime;
  697         struct l_times_argv tms;
  698         struct proc *p;
  699         int error;
  700 
  701 #ifdef DEBUG
  702         if (ldebug(times))
  703                 printf(ARGS(times, "*"));
  704 #endif
  705 
  706         if (args->buf != NULL) {
  707                 p = td->td_proc;
  708                 PROC_LOCK(p);
  709                 PROC_STATLOCK(p);
  710                 calcru(p, &utime, &stime);
  711                 PROC_STATUNLOCK(p);
  712                 calccru(p, &cutime, &cstime);
  713                 PROC_UNLOCK(p);
  714 
  715                 tms.tms_utime = CONVTCK(utime);
  716                 tms.tms_stime = CONVTCK(stime);
  717 
  718                 tms.tms_cutime = CONVTCK(cutime);
  719                 tms.tms_cstime = CONVTCK(cstime);
  720 
  721                 if ((error = copyout(&tms, args->buf, sizeof(tms))))
  722                         return (error);
  723         }
  724 
  725         microuptime(&tv);
  726         td->td_retval[0] = (int)CONVTCK(tv);
  727         return (0);
  728 }
  729 
  730 int
  731 linux_newuname(struct thread *td, struct linux_newuname_args *args)
  732 {
  733         struct l_new_utsname utsname;
  734         char osname[LINUX_MAX_UTSNAME];
  735         char osrelease[LINUX_MAX_UTSNAME];
  736         char *p;
  737 
  738 #ifdef DEBUG
  739         if (ldebug(newuname))
  740                 printf(ARGS(newuname, "*"));
  741 #endif
  742 
  743         linux_get_osname(td, osname);
  744         linux_get_osrelease(td, osrelease);
  745 
  746         bzero(&utsname, sizeof(utsname));
  747         strlcpy(utsname.sysname, osname, LINUX_MAX_UTSNAME);
  748         getcredhostname(td->td_ucred, utsname.nodename, LINUX_MAX_UTSNAME);
  749         getcreddomainname(td->td_ucred, utsname.domainname, LINUX_MAX_UTSNAME);
  750         strlcpy(utsname.release, osrelease, LINUX_MAX_UTSNAME);
  751         strlcpy(utsname.version, version, LINUX_MAX_UTSNAME);
  752         for (p = utsname.version; *p != '\0'; ++p)
  753                 if (*p == '\n') {
  754                         *p = '\0';
  755                         break;
  756                 }
  757         strlcpy(utsname.machine, linux_kplatform, LINUX_MAX_UTSNAME);
  758 
  759         return (copyout(&utsname, args->buf, sizeof(utsname)));
  760 }
  761 
  762 struct l_utimbuf {
  763         l_time_t l_actime;
  764         l_time_t l_modtime;
  765 };
  766 
  767 int
  768 linux_utime(struct thread *td, struct linux_utime_args *args)
  769 {
  770         struct timeval tv[2], *tvp;
  771         struct l_utimbuf lut;
  772         char *fname;
  773         int error;
  774 
  775         LCONVPATHEXIST(td, args->fname, &fname);
  776 
  777 #ifdef DEBUG
  778         if (ldebug(utime))
  779                 printf(ARGS(utime, "%s, *"), fname);
  780 #endif
  781 
  782         if (args->times) {
  783                 if ((error = copyin(args->times, &lut, sizeof lut))) {
  784                         LFREEPATH(fname);
  785                         return (error);
  786                 }
  787                 tv[0].tv_sec = lut.l_actime;
  788                 tv[0].tv_usec = 0;
  789                 tv[1].tv_sec = lut.l_modtime;
  790                 tv[1].tv_usec = 0;
  791                 tvp = tv;
  792         } else
  793                 tvp = NULL;
  794 
  795         error = kern_utimesat(td, AT_FDCWD, fname, UIO_SYSSPACE, tvp,
  796             UIO_SYSSPACE);
  797         LFREEPATH(fname);
  798         return (error);
  799 }
  800 
  801 int
  802 linux_utimes(struct thread *td, struct linux_utimes_args *args)
  803 {
  804         l_timeval ltv[2];
  805         struct timeval tv[2], *tvp = NULL;
  806         char *fname;
  807         int error;
  808 
  809         LCONVPATHEXIST(td, args->fname, &fname);
  810 
  811 #ifdef DEBUG
  812         if (ldebug(utimes))
  813                 printf(ARGS(utimes, "%s, *"), fname);
  814 #endif
  815 
  816         if (args->tptr != NULL) {
  817                 if ((error = copyin(args->tptr, ltv, sizeof ltv))) {
  818                         LFREEPATH(fname);
  819                         return (error);
  820                 }
  821                 tv[0].tv_sec = ltv[0].tv_sec;
  822                 tv[0].tv_usec = ltv[0].tv_usec;
  823                 tv[1].tv_sec = ltv[1].tv_sec;
  824                 tv[1].tv_usec = ltv[1].tv_usec;
  825                 tvp = tv;
  826         }
  827 
  828         error = kern_utimesat(td, AT_FDCWD, fname, UIO_SYSSPACE,
  829             tvp, UIO_SYSSPACE);
  830         LFREEPATH(fname);
  831         return (error);
  832 }
  833 
  834 static int
  835 linux_utimensat_nsec_valid(l_long nsec)
  836 {
  837 
  838         if (nsec == LINUX_UTIME_OMIT || nsec == LINUX_UTIME_NOW)
  839                 return (0);
  840         if (nsec >= 0 && nsec <= 999999999)
  841                 return (0);
  842         return (1);
  843 }
  844 
  845 int 
  846 linux_utimensat(struct thread *td, struct linux_utimensat_args *args)
  847 {
  848         struct l_timespec l_times[2];
  849         struct timespec times[2], *timesp = NULL;
  850         char *path = NULL;
  851         int error, dfd, flags = 0;
  852 
  853         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
  854 
  855 #ifdef DEBUG
  856         if (ldebug(utimensat))
  857                 printf(ARGS(utimensat, "%d, *"), dfd);
  858 #endif
  859 
  860         if (args->flags & ~LINUX_AT_SYMLINK_NOFOLLOW)
  861                 return (EINVAL);
  862 
  863         if (args->times != NULL) {
  864                 error = copyin(args->times, l_times, sizeof(l_times));
  865                 if (error != 0)
  866                         return (error);
  867 
  868                 if (linux_utimensat_nsec_valid(l_times[0].tv_nsec) != 0 ||
  869                     linux_utimensat_nsec_valid(l_times[1].tv_nsec) != 0)
  870                         return (EINVAL);
  871 
  872                 times[0].tv_sec = l_times[0].tv_sec;
  873                 switch (l_times[0].tv_nsec)
  874                 {
  875                 case LINUX_UTIME_OMIT:
  876                         times[0].tv_nsec = UTIME_OMIT;
  877                         break;
  878                 case LINUX_UTIME_NOW:
  879                         times[0].tv_nsec = UTIME_NOW;
  880                         break;
  881                 default:
  882                         times[0].tv_nsec = l_times[0].tv_nsec;
  883                 }
  884 
  885                 times[1].tv_sec = l_times[1].tv_sec;
  886                 switch (l_times[1].tv_nsec)
  887                 {
  888                 case LINUX_UTIME_OMIT:
  889                         times[1].tv_nsec = UTIME_OMIT;
  890                         break;
  891                 case LINUX_UTIME_NOW:
  892                         times[1].tv_nsec = UTIME_NOW;
  893                         break;
  894                 default:
  895                         times[1].tv_nsec = l_times[1].tv_nsec;
  896                         break;
  897                 }
  898                 timesp = times;
  899 
  900                 /* This breaks POSIX, but is what the Linux kernel does
  901                  * _on purpose_ (documented in the man page for utimensat(2)),
  902                  * so we must follow that behaviour. */
  903                 if (times[0].tv_nsec == UTIME_OMIT &&
  904                     times[1].tv_nsec == UTIME_OMIT)
  905                         return (0);
  906         }
  907 
  908         if (args->pathname != NULL)
  909                 LCONVPATHEXIST_AT(td, args->pathname, &path, dfd);
  910         else if (args->flags != 0)
  911                 return (EINVAL);
  912 
  913         if (args->flags & LINUX_AT_SYMLINK_NOFOLLOW)
  914                 flags |= AT_SYMLINK_NOFOLLOW;
  915 
  916         if (path == NULL)
  917                 error = kern_futimens(td, dfd, timesp, UIO_SYSSPACE);
  918         else {
  919                 error = kern_utimensat(td, dfd, path, UIO_SYSSPACE, timesp,
  920                         UIO_SYSSPACE, flags);
  921                 LFREEPATH(path);
  922         }
  923 
  924         return (error);
  925 }
  926 
  927 int
  928 linux_futimesat(struct thread *td, struct linux_futimesat_args *args)
  929 {
  930         l_timeval ltv[2];
  931         struct timeval tv[2], *tvp = NULL;
  932         char *fname;
  933         int error, dfd;
  934 
  935         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
  936         LCONVPATHEXIST_AT(td, args->filename, &fname, dfd);
  937 
  938 #ifdef DEBUG
  939         if (ldebug(futimesat))
  940                 printf(ARGS(futimesat, "%s, *"), fname);
  941 #endif
  942 
  943         if (args->utimes != NULL) {
  944                 if ((error = copyin(args->utimes, ltv, sizeof ltv))) {
  945                         LFREEPATH(fname);
  946                         return (error);
  947                 }
  948                 tv[0].tv_sec = ltv[0].tv_sec;
  949                 tv[0].tv_usec = ltv[0].tv_usec;
  950                 tv[1].tv_sec = ltv[1].tv_sec;
  951                 tv[1].tv_usec = ltv[1].tv_usec;
  952                 tvp = tv;
  953         }
  954 
  955         error = kern_utimesat(td, dfd, fname, UIO_SYSSPACE, tvp, UIO_SYSSPACE);
  956         LFREEPATH(fname);
  957         return (error);
  958 }
  959 
  960 int
  961 linux_common_wait(struct thread *td, int pid, int *status,
  962     int options, struct rusage *ru)
  963 {
  964         int error, tmpstat;
  965 
  966         error = kern_wait(td, pid, &tmpstat, options, ru);
  967         if (error)
  968                 return (error);
  969 
  970         if (status) {
  971                 tmpstat &= 0xffff;
  972                 if (WIFSIGNALED(tmpstat))
  973                         tmpstat = (tmpstat & 0xffffff80) |
  974                             bsd_to_linux_signal(WTERMSIG(tmpstat));
  975                 else if (WIFSTOPPED(tmpstat))
  976                         tmpstat = (tmpstat & 0xffff00ff) |
  977                             (bsd_to_linux_signal(WSTOPSIG(tmpstat)) << 8);
  978                 else if (WIFCONTINUED(tmpstat))
  979                         tmpstat = 0xffff;
  980                 error = copyout(&tmpstat, status, sizeof(int));
  981         }
  982 
  983         return (error);
  984 }
  985 
  986 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
  987 int
  988 linux_waitpid(struct thread *td, struct linux_waitpid_args *args)
  989 {
  990         struct linux_wait4_args wait4_args;
  991 
  992 #ifdef DEBUG
  993         if (ldebug(waitpid))
  994                 printf(ARGS(waitpid, "%d, %p, %d"),
  995                     args->pid, (void *)args->status, args->options);
  996 #endif
  997 
  998         wait4_args.pid = args->pid;
  999         wait4_args.status = args->status;
 1000         wait4_args.options = args->options;
 1001         wait4_args.rusage = NULL;
 1002 
 1003         return (linux_wait4(td, &wait4_args));
 1004 }
 1005 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 1006 
 1007 int
 1008 linux_wait4(struct thread *td, struct linux_wait4_args *args)
 1009 {
 1010         int error, options;
 1011         struct rusage ru, *rup;
 1012 
 1013 #ifdef DEBUG
 1014         if (ldebug(wait4))
 1015                 printf(ARGS(wait4, "%d, %p, %d, %p"),
 1016                     args->pid, (void *)args->status, args->options,
 1017                     (void *)args->rusage);
 1018 #endif
 1019         if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
 1020             LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
 1021                 return (EINVAL);
 1022 
 1023         options = WEXITED;
 1024         linux_to_bsd_waitopts(args->options, &options);
 1025 
 1026         if (args->rusage != NULL)
 1027                 rup = &ru;
 1028         else
 1029                 rup = NULL;
 1030         error = linux_common_wait(td, args->pid, args->status, options, rup);
 1031         if (error != 0)
 1032                 return (error);
 1033         if (args->rusage != NULL)
 1034                 error = linux_copyout_rusage(&ru, args->rusage);
 1035         return (error);
 1036 }
 1037 
 1038 int
 1039 linux_waitid(struct thread *td, struct linux_waitid_args *args)
 1040 {
 1041         int status, options, sig;
 1042         struct __wrusage wru;
 1043         siginfo_t siginfo;
 1044         l_siginfo_t lsi;
 1045         idtype_t idtype;
 1046         struct proc *p;
 1047         int error;
 1048 
 1049         options = 0;
 1050         linux_to_bsd_waitopts(args->options, &options);
 1051 
 1052         if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))
 1053                 return (EINVAL);
 1054         if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))
 1055                 return (EINVAL);
 1056 
 1057         switch (args->idtype) {
 1058         case LINUX_P_ALL:
 1059                 idtype = P_ALL;
 1060                 break;
 1061         case LINUX_P_PID:
 1062                 if (args->id <= 0)
 1063                         return (EINVAL);
 1064                 idtype = P_PID;
 1065                 break;
 1066         case LINUX_P_PGID:
 1067                 if (args->id <= 0)
 1068                         return (EINVAL);
 1069                 idtype = P_PGID;
 1070                 break;
 1071         default:
 1072                 return (EINVAL);
 1073         }
 1074 
 1075         error = kern_wait6(td, idtype, args->id, &status, options,
 1076             &wru, &siginfo);
 1077         if (error != 0)
 1078                 return (error);
 1079         if (args->rusage != NULL) {
 1080                 error = linux_copyout_rusage(&wru.wru_children,
 1081                     args->rusage);
 1082                 if (error != 0)
 1083                         return (error);
 1084         }
 1085         if (args->info != NULL) {
 1086                 p = td->td_proc;
 1087                 if (td->td_retval[0] == 0)
 1088                         bzero(&lsi, sizeof(lsi));
 1089                 else {
 1090                         sig = bsd_to_linux_signal(siginfo.si_signo);
 1091                         siginfo_to_lsiginfo(&siginfo, &lsi, sig);
 1092                 }
 1093                 error = copyout(&lsi, args->info, sizeof(lsi));
 1094         }
 1095         td->td_retval[0] = 0;
 1096 
 1097         return (error);
 1098 }
 1099 
 1100 int
 1101 linux_mknod(struct thread *td, struct linux_mknod_args *args)
 1102 {
 1103         char *path;
 1104         int error;
 1105 
 1106         LCONVPATHCREAT(td, args->path, &path);
 1107 
 1108 #ifdef DEBUG
 1109         if (ldebug(mknod))
 1110                 printf(ARGS(mknod, "%s, %d, %ju"), path, args->mode,
 1111                     (uintmax_t)args->dev);
 1112 #endif
 1113 
 1114         switch (args->mode & S_IFMT) {
 1115         case S_IFIFO:
 1116         case S_IFSOCK:
 1117                 error = kern_mkfifoat(td, AT_FDCWD, path, UIO_SYSSPACE,
 1118                     args->mode);
 1119                 break;
 1120 
 1121         case S_IFCHR:
 1122         case S_IFBLK:
 1123                 error = kern_mknodat(td, AT_FDCWD, path, UIO_SYSSPACE,
 1124                     args->mode, args->dev);
 1125                 break;
 1126 
 1127         case S_IFDIR:
 1128                 error = EPERM;
 1129                 break;
 1130 
 1131         case 0:
 1132                 args->mode |= S_IFREG;
 1133                 /* FALLTHROUGH */
 1134         case S_IFREG:
 1135                 error = kern_openat(td, AT_FDCWD, path, UIO_SYSSPACE,
 1136                     O_WRONLY | O_CREAT | O_TRUNC, args->mode);
 1137                 if (error == 0)
 1138                         kern_close(td, td->td_retval[0]);
 1139                 break;
 1140 
 1141         default:
 1142                 error = EINVAL;
 1143                 break;
 1144         }
 1145         LFREEPATH(path);
 1146         return (error);
 1147 }
 1148 
 1149 int
 1150 linux_mknodat(struct thread *td, struct linux_mknodat_args *args)
 1151 {
 1152         char *path;
 1153         int error, dfd;
 1154 
 1155         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 1156         LCONVPATHCREAT_AT(td, args->filename, &path, dfd);
 1157 
 1158 #ifdef DEBUG
 1159         if (ldebug(mknodat))
 1160                 printf(ARGS(mknodat, "%s, %d, %d"), path, args->mode, args->dev);
 1161 #endif
 1162 
 1163         switch (args->mode & S_IFMT) {
 1164         case S_IFIFO:
 1165         case S_IFSOCK:
 1166                 error = kern_mkfifoat(td, dfd, path, UIO_SYSSPACE, args->mode);
 1167                 break;
 1168 
 1169         case S_IFCHR:
 1170         case S_IFBLK:
 1171                 error = kern_mknodat(td, dfd, path, UIO_SYSSPACE, args->mode,
 1172                     args->dev);
 1173                 break;
 1174 
 1175         case S_IFDIR:
 1176                 error = EPERM;
 1177                 break;
 1178 
 1179         case 0:
 1180                 args->mode |= S_IFREG;
 1181                 /* FALLTHROUGH */
 1182         case S_IFREG:
 1183                 error = kern_openat(td, dfd, path, UIO_SYSSPACE,
 1184                     O_WRONLY | O_CREAT | O_TRUNC, args->mode);
 1185                 if (error == 0)
 1186                         kern_close(td, td->td_retval[0]);
 1187                 break;
 1188 
 1189         default:
 1190                 error = EINVAL;
 1191                 break;
 1192         }
 1193         LFREEPATH(path);
 1194         return (error);
 1195 }
 1196 
 1197 /*
 1198  * UGH! This is just about the dumbest idea I've ever heard!!
 1199  */
 1200 int
 1201 linux_personality(struct thread *td, struct linux_personality_args *args)
 1202 {
 1203         struct linux_pemuldata *pem;
 1204         struct proc *p = td->td_proc;
 1205         uint32_t old;
 1206 
 1207 #ifdef DEBUG
 1208         if (ldebug(personality))
 1209                 printf(ARGS(personality, "%u"), args->per);
 1210 #endif
 1211 
 1212         PROC_LOCK(p);
 1213         pem = pem_find(p);
 1214         old = pem->persona;
 1215         if (args->per != 0xffffffff)
 1216                 pem->persona = args->per;
 1217         PROC_UNLOCK(p);
 1218 
 1219         td->td_retval[0] = old;
 1220         return (0);
 1221 }
 1222 
 1223 struct l_itimerval {
 1224         l_timeval it_interval;
 1225         l_timeval it_value;
 1226 };
 1227 
 1228 #define B2L_ITIMERVAL(bip, lip)                                         \
 1229         (bip)->it_interval.tv_sec = (lip)->it_interval.tv_sec;          \
 1230         (bip)->it_interval.tv_usec = (lip)->it_interval.tv_usec;        \
 1231         (bip)->it_value.tv_sec = (lip)->it_value.tv_sec;                \
 1232         (bip)->it_value.tv_usec = (lip)->it_value.tv_usec;
 1233 
 1234 int
 1235 linux_setitimer(struct thread *td, struct linux_setitimer_args *uap)
 1236 {
 1237         int error;
 1238         struct l_itimerval ls;
 1239         struct itimerval aitv, oitv;
 1240 
 1241 #ifdef DEBUG
 1242         if (ldebug(setitimer))
 1243                 printf(ARGS(setitimer, "%p, %p"),
 1244                     (void *)uap->itv, (void *)uap->oitv);
 1245 #endif
 1246 
 1247         if (uap->itv == NULL) {
 1248                 uap->itv = uap->oitv;
 1249                 return (linux_getitimer(td, (struct linux_getitimer_args *)uap));
 1250         }
 1251 
 1252         error = copyin(uap->itv, &ls, sizeof(ls));
 1253         if (error != 0)
 1254                 return (error);
 1255         B2L_ITIMERVAL(&aitv, &ls);
 1256 #ifdef DEBUG
 1257         if (ldebug(setitimer)) {
 1258                 printf("setitimer: value: sec: %jd, usec: %ld\n",
 1259                     (intmax_t)aitv.it_value.tv_sec, aitv.it_value.tv_usec);
 1260                 printf("setitimer: interval: sec: %jd, usec: %ld\n",
 1261                     (intmax_t)aitv.it_interval.tv_sec, aitv.it_interval.tv_usec);
 1262         }
 1263 #endif
 1264         error = kern_setitimer(td, uap->which, &aitv, &oitv);
 1265         if (error != 0 || uap->oitv == NULL)
 1266                 return (error);
 1267         B2L_ITIMERVAL(&ls, &oitv);
 1268 
 1269         return (copyout(&ls, uap->oitv, sizeof(ls)));
 1270 }
 1271 
 1272 int
 1273 linux_getitimer(struct thread *td, struct linux_getitimer_args *uap)
 1274 {
 1275         int error;
 1276         struct l_itimerval ls;
 1277         struct itimerval aitv;
 1278 
 1279 #ifdef DEBUG
 1280         if (ldebug(getitimer))
 1281                 printf(ARGS(getitimer, "%p"), (void *)uap->itv);
 1282 #endif
 1283         error = kern_getitimer(td, uap->which, &aitv);
 1284         if (error != 0)
 1285                 return (error);
 1286         B2L_ITIMERVAL(&ls, &aitv);
 1287         return (copyout(&ls, uap->itv, sizeof(ls)));
 1288 }
 1289 
 1290 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 1291 int
 1292 linux_nice(struct thread *td, struct linux_nice_args *args)
 1293 {
 1294         struct setpriority_args bsd_args;
 1295 
 1296         bsd_args.which = PRIO_PROCESS;
 1297         bsd_args.who = 0;               /* current process */
 1298         bsd_args.prio = args->inc;
 1299         return (sys_setpriority(td, &bsd_args));
 1300 }
 1301 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 1302 
 1303 int
 1304 linux_setgroups(struct thread *td, struct linux_setgroups_args *args)
 1305 {
 1306         struct ucred *newcred, *oldcred;
 1307         l_gid_t *linux_gidset;
 1308         gid_t *bsd_gidset;
 1309         int ngrp, error;
 1310         struct proc *p;
 1311 
 1312         ngrp = args->gidsetsize;
 1313         if (ngrp < 0 || ngrp >= ngroups_max + 1)
 1314                 return (EINVAL);
 1315         linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_LINUX, M_WAITOK);
 1316         error = copyin(args->grouplist, linux_gidset, ngrp * sizeof(l_gid_t));
 1317         if (error)
 1318                 goto out;
 1319         newcred = crget();
 1320         crextend(newcred, ngrp + 1);
 1321         p = td->td_proc;
 1322         PROC_LOCK(p);
 1323         oldcred = p->p_ucred;
 1324         crcopy(newcred, oldcred);
 1325 
 1326         /*
 1327          * cr_groups[0] holds egid. Setting the whole set from
 1328          * the supplied set will cause egid to be changed too.
 1329          * Keep cr_groups[0] unchanged to prevent that.
 1330          */
 1331 
 1332         if ((error = priv_check_cred(oldcred, PRIV_CRED_SETGROUPS, 0)) != 0) {
 1333                 PROC_UNLOCK(p);
 1334                 crfree(newcred);
 1335                 goto out;
 1336         }
 1337 
 1338         if (ngrp > 0) {
 1339                 newcred->cr_ngroups = ngrp + 1;
 1340 
 1341                 bsd_gidset = newcred->cr_groups;
 1342                 ngrp--;
 1343                 while (ngrp >= 0) {
 1344                         bsd_gidset[ngrp + 1] = linux_gidset[ngrp];
 1345                         ngrp--;
 1346                 }
 1347         } else
 1348                 newcred->cr_ngroups = 1;
 1349 
 1350         setsugid(p);
 1351         proc_set_cred(p, newcred);
 1352         PROC_UNLOCK(p);
 1353         crfree(oldcred);
 1354         error = 0;
 1355 out:
 1356         free(linux_gidset, M_LINUX);
 1357         return (error);
 1358 }
 1359 
 1360 int
 1361 linux_getgroups(struct thread *td, struct linux_getgroups_args *args)
 1362 {
 1363         struct ucred *cred;
 1364         l_gid_t *linux_gidset;
 1365         gid_t *bsd_gidset;
 1366         int bsd_gidsetsz, ngrp, error;
 1367 
 1368         cred = td->td_ucred;
 1369         bsd_gidset = cred->cr_groups;
 1370         bsd_gidsetsz = cred->cr_ngroups - 1;
 1371 
 1372         /*
 1373          * cr_groups[0] holds egid. Returning the whole set
 1374          * here will cause a duplicate. Exclude cr_groups[0]
 1375          * to prevent that.
 1376          */
 1377 
 1378         if ((ngrp = args->gidsetsize) == 0) {
 1379                 td->td_retval[0] = bsd_gidsetsz;
 1380                 return (0);
 1381         }
 1382 
 1383         if (ngrp < bsd_gidsetsz)
 1384                 return (EINVAL);
 1385 
 1386         ngrp = 0;
 1387         linux_gidset = malloc(bsd_gidsetsz * sizeof(*linux_gidset),
 1388             M_LINUX, M_WAITOK);
 1389         while (ngrp < bsd_gidsetsz) {
 1390                 linux_gidset[ngrp] = bsd_gidset[ngrp + 1];
 1391                 ngrp++;
 1392         }
 1393 
 1394         error = copyout(linux_gidset, args->grouplist, ngrp * sizeof(l_gid_t));
 1395         free(linux_gidset, M_LINUX);
 1396         if (error)
 1397                 return (error);
 1398 
 1399         td->td_retval[0] = ngrp;
 1400         return (0);
 1401 }
 1402 
 1403 int
 1404 linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args)
 1405 {
 1406         struct rlimit bsd_rlim;
 1407         struct l_rlimit rlim;
 1408         u_int which;
 1409         int error;
 1410 
 1411 #ifdef DEBUG
 1412         if (ldebug(setrlimit))
 1413                 printf(ARGS(setrlimit, "%d, %p"),
 1414                     args->resource, (void *)args->rlim);
 1415 #endif
 1416 
 1417         if (args->resource >= LINUX_RLIM_NLIMITS)
 1418                 return (EINVAL);
 1419 
 1420         which = linux_to_bsd_resource[args->resource];
 1421         if (which == -1)
 1422                 return (EINVAL);
 1423 
 1424         error = copyin(args->rlim, &rlim, sizeof(rlim));
 1425         if (error)
 1426                 return (error);
 1427 
 1428         bsd_rlim.rlim_cur = (rlim_t)rlim.rlim_cur;
 1429         bsd_rlim.rlim_max = (rlim_t)rlim.rlim_max;
 1430         return (kern_setrlimit(td, which, &bsd_rlim));
 1431 }
 1432 
 1433 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 1434 int
 1435 linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
 1436 {
 1437         struct l_rlimit rlim;
 1438         struct rlimit bsd_rlim;
 1439         u_int which;
 1440 
 1441 #ifdef DEBUG
 1442         if (ldebug(old_getrlimit))
 1443                 printf(ARGS(old_getrlimit, "%d, %p"),
 1444                     args->resource, (void *)args->rlim);
 1445 #endif
 1446 
 1447         if (args->resource >= LINUX_RLIM_NLIMITS)
 1448                 return (EINVAL);
 1449 
 1450         which = linux_to_bsd_resource[args->resource];
 1451         if (which == -1)
 1452                 return (EINVAL);
 1453 
 1454         lim_rlimit(td, which, &bsd_rlim);
 1455 
 1456 #ifdef COMPAT_LINUX32
 1457         rlim.rlim_cur = (unsigned int)bsd_rlim.rlim_cur;
 1458         if (rlim.rlim_cur == UINT_MAX)
 1459                 rlim.rlim_cur = INT_MAX;
 1460         rlim.rlim_max = (unsigned int)bsd_rlim.rlim_max;
 1461         if (rlim.rlim_max == UINT_MAX)
 1462                 rlim.rlim_max = INT_MAX;
 1463 #else
 1464         rlim.rlim_cur = (unsigned long)bsd_rlim.rlim_cur;
 1465         if (rlim.rlim_cur == ULONG_MAX)
 1466                 rlim.rlim_cur = LONG_MAX;
 1467         rlim.rlim_max = (unsigned long)bsd_rlim.rlim_max;
 1468         if (rlim.rlim_max == ULONG_MAX)
 1469                 rlim.rlim_max = LONG_MAX;
 1470 #endif
 1471         return (copyout(&rlim, args->rlim, sizeof(rlim)));
 1472 }
 1473 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 1474 
 1475 int
 1476 linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
 1477 {
 1478         struct l_rlimit rlim;
 1479         struct rlimit bsd_rlim;
 1480         u_int which;
 1481 
 1482 #ifdef DEBUG
 1483         if (ldebug(getrlimit))
 1484                 printf(ARGS(getrlimit, "%d, %p"),
 1485                     args->resource, (void *)args->rlim);
 1486 #endif
 1487 
 1488         if (args->resource >= LINUX_RLIM_NLIMITS)
 1489                 return (EINVAL);
 1490 
 1491         which = linux_to_bsd_resource[args->resource];
 1492         if (which == -1)
 1493                 return (EINVAL);
 1494 
 1495         lim_rlimit(td, which, &bsd_rlim);
 1496 
 1497         rlim.rlim_cur = (l_ulong)bsd_rlim.rlim_cur;
 1498         rlim.rlim_max = (l_ulong)bsd_rlim.rlim_max;
 1499         return (copyout(&rlim, args->rlim, sizeof(rlim)));
 1500 }
 1501 
 1502 int
 1503 linux_sched_setscheduler(struct thread *td,
 1504     struct linux_sched_setscheduler_args *args)
 1505 {
 1506         struct sched_param sched_param;
 1507         struct thread *tdt;
 1508         int error, policy;
 1509 
 1510 #ifdef DEBUG
 1511         if (ldebug(sched_setscheduler))
 1512                 printf(ARGS(sched_setscheduler, "%d, %d, %p"),
 1513                     args->pid, args->policy, (const void *)args->param);
 1514 #endif
 1515 
 1516         switch (args->policy) {
 1517         case LINUX_SCHED_OTHER:
 1518                 policy = SCHED_OTHER;
 1519                 break;
 1520         case LINUX_SCHED_FIFO:
 1521                 policy = SCHED_FIFO;
 1522                 break;
 1523         case LINUX_SCHED_RR:
 1524                 policy = SCHED_RR;
 1525                 break;
 1526         default:
 1527                 return (EINVAL);
 1528         }
 1529 
 1530         error = copyin(args->param, &sched_param, sizeof(sched_param));
 1531         if (error)
 1532                 return (error);
 1533 
 1534         tdt = linux_tdfind(td, args->pid, -1);
 1535         if (tdt == NULL)
 1536                 return (ESRCH);
 1537 
 1538         error = kern_sched_setscheduler(td, tdt, policy, &sched_param);
 1539         PROC_UNLOCK(tdt->td_proc);
 1540         return (error);
 1541 }
 1542 
 1543 int
 1544 linux_sched_getscheduler(struct thread *td,
 1545     struct linux_sched_getscheduler_args *args)
 1546 {
 1547         struct thread *tdt;
 1548         int error, policy;
 1549 
 1550 #ifdef DEBUG
 1551         if (ldebug(sched_getscheduler))
 1552                 printf(ARGS(sched_getscheduler, "%d"), args->pid);
 1553 #endif
 1554 
 1555         tdt = linux_tdfind(td, args->pid, -1);
 1556         if (tdt == NULL)
 1557                 return (ESRCH);
 1558 
 1559         error = kern_sched_getscheduler(td, tdt, &policy);
 1560         PROC_UNLOCK(tdt->td_proc);
 1561 
 1562         switch (policy) {
 1563         case SCHED_OTHER:
 1564                 td->td_retval[0] = LINUX_SCHED_OTHER;
 1565                 break;
 1566         case SCHED_FIFO:
 1567                 td->td_retval[0] = LINUX_SCHED_FIFO;
 1568                 break;
 1569         case SCHED_RR:
 1570                 td->td_retval[0] = LINUX_SCHED_RR;
 1571                 break;
 1572         }
 1573         return (error);
 1574 }
 1575 
 1576 int
 1577 linux_sched_get_priority_max(struct thread *td,
 1578     struct linux_sched_get_priority_max_args *args)
 1579 {
 1580         struct sched_get_priority_max_args bsd;
 1581 
 1582 #ifdef DEBUG
 1583         if (ldebug(sched_get_priority_max))
 1584                 printf(ARGS(sched_get_priority_max, "%d"), args->policy);
 1585 #endif
 1586 
 1587         switch (args->policy) {
 1588         case LINUX_SCHED_OTHER:
 1589                 bsd.policy = SCHED_OTHER;
 1590                 break;
 1591         case LINUX_SCHED_FIFO:
 1592                 bsd.policy = SCHED_FIFO;
 1593                 break;
 1594         case LINUX_SCHED_RR:
 1595                 bsd.policy = SCHED_RR;
 1596                 break;
 1597         default:
 1598                 return (EINVAL);
 1599         }
 1600         return (sys_sched_get_priority_max(td, &bsd));
 1601 }
 1602 
 1603 int
 1604 linux_sched_get_priority_min(struct thread *td,
 1605     struct linux_sched_get_priority_min_args *args)
 1606 {
 1607         struct sched_get_priority_min_args bsd;
 1608 
 1609 #ifdef DEBUG
 1610         if (ldebug(sched_get_priority_min))
 1611                 printf(ARGS(sched_get_priority_min, "%d"), args->policy);
 1612 #endif
 1613 
 1614         switch (args->policy) {
 1615         case LINUX_SCHED_OTHER:
 1616                 bsd.policy = SCHED_OTHER;
 1617                 break;
 1618         case LINUX_SCHED_FIFO:
 1619                 bsd.policy = SCHED_FIFO;
 1620                 break;
 1621         case LINUX_SCHED_RR:
 1622                 bsd.policy = SCHED_RR;
 1623                 break;
 1624         default:
 1625                 return (EINVAL);
 1626         }
 1627         return (sys_sched_get_priority_min(td, &bsd));
 1628 }
 1629 
 1630 #define REBOOT_CAD_ON   0x89abcdef
 1631 #define REBOOT_CAD_OFF  0
 1632 #define REBOOT_HALT     0xcdef0123
 1633 #define REBOOT_RESTART  0x01234567
 1634 #define REBOOT_RESTART2 0xA1B2C3D4
 1635 #define REBOOT_POWEROFF 0x4321FEDC
 1636 #define REBOOT_MAGIC1   0xfee1dead
 1637 #define REBOOT_MAGIC2   0x28121969
 1638 #define REBOOT_MAGIC2A  0x05121996
 1639 #define REBOOT_MAGIC2B  0x16041998
 1640 
 1641 int
 1642 linux_reboot(struct thread *td, struct linux_reboot_args *args)
 1643 {
 1644         struct reboot_args bsd_args;
 1645 
 1646 #ifdef DEBUG
 1647         if (ldebug(reboot))
 1648                 printf(ARGS(reboot, "0x%x"), args->cmd);
 1649 #endif
 1650 
 1651         if (args->magic1 != REBOOT_MAGIC1)
 1652                 return (EINVAL);
 1653 
 1654         switch (args->magic2) {
 1655         case REBOOT_MAGIC2:
 1656         case REBOOT_MAGIC2A:
 1657         case REBOOT_MAGIC2B:
 1658                 break;
 1659         default:
 1660                 return (EINVAL);
 1661         }
 1662 
 1663         switch (args->cmd) {
 1664         case REBOOT_CAD_ON:
 1665         case REBOOT_CAD_OFF:
 1666                 return (priv_check(td, PRIV_REBOOT));
 1667         case REBOOT_HALT:
 1668                 bsd_args.opt = RB_HALT;
 1669                 break;
 1670         case REBOOT_RESTART:
 1671         case REBOOT_RESTART2:
 1672                 bsd_args.opt = 0;
 1673                 break;
 1674         case REBOOT_POWEROFF:
 1675                 bsd_args.opt = RB_POWEROFF;
 1676                 break;
 1677         default:
 1678                 return (EINVAL);
 1679         }
 1680         return (sys_reboot(td, &bsd_args));
 1681 }
 1682 
 1683 
 1684 /*
 1685  * The FreeBSD native getpid(2), getgid(2) and getuid(2) also modify
 1686  * td->td_retval[1] when COMPAT_43 is defined. This clobbers registers that
 1687  * are assumed to be preserved. The following lightweight syscalls fixes
 1688  * this. See also linux_getgid16() and linux_getuid16() in linux_uid16.c
 1689  *
 1690  * linux_getpid() - MP SAFE
 1691  * linux_getgid() - MP SAFE
 1692  * linux_getuid() - MP SAFE
 1693  */
 1694 
 1695 int
 1696 linux_getpid(struct thread *td, struct linux_getpid_args *args)
 1697 {
 1698 
 1699 #ifdef DEBUG
 1700         if (ldebug(getpid))
 1701                 printf(ARGS(getpid, ""));
 1702 #endif
 1703         td->td_retval[0] = td->td_proc->p_pid;
 1704 
 1705         return (0);
 1706 }
 1707 
 1708 int
 1709 linux_gettid(struct thread *td, struct linux_gettid_args *args)
 1710 {
 1711         struct linux_emuldata *em;
 1712 
 1713 #ifdef DEBUG
 1714         if (ldebug(gettid))
 1715                 printf(ARGS(gettid, ""));
 1716 #endif
 1717 
 1718         em = em_find(td);
 1719         KASSERT(em != NULL, ("gettid: emuldata not found.\n"));
 1720 
 1721         td->td_retval[0] = em->em_tid;
 1722 
 1723         return (0);
 1724 }
 1725 
 1726 
 1727 int
 1728 linux_getppid(struct thread *td, struct linux_getppid_args *args)
 1729 {
 1730 
 1731 #ifdef DEBUG
 1732         if (ldebug(getppid))
 1733                 printf(ARGS(getppid, ""));
 1734 #endif
 1735 
 1736         PROC_LOCK(td->td_proc);
 1737         td->td_retval[0] = td->td_proc->p_pptr->p_pid;
 1738         PROC_UNLOCK(td->td_proc);
 1739         return (0);
 1740 }
 1741 
 1742 int
 1743 linux_getgid(struct thread *td, struct linux_getgid_args *args)
 1744 {
 1745 
 1746 #ifdef DEBUG
 1747         if (ldebug(getgid))
 1748                 printf(ARGS(getgid, ""));
 1749 #endif
 1750 
 1751         td->td_retval[0] = td->td_ucred->cr_rgid;
 1752         return (0);
 1753 }
 1754 
 1755 int
 1756 linux_getuid(struct thread *td, struct linux_getuid_args *args)
 1757 {
 1758 
 1759 #ifdef DEBUG
 1760         if (ldebug(getuid))
 1761                 printf(ARGS(getuid, ""));
 1762 #endif
 1763 
 1764         td->td_retval[0] = td->td_ucred->cr_ruid;
 1765         return (0);
 1766 }
 1767 
 1768 
 1769 int
 1770 linux_getsid(struct thread *td, struct linux_getsid_args *args)
 1771 {
 1772         struct getsid_args bsd;
 1773 
 1774 #ifdef DEBUG
 1775         if (ldebug(getsid))
 1776                 printf(ARGS(getsid, "%i"), args->pid);
 1777 #endif
 1778 
 1779         bsd.pid = args->pid;
 1780         return (sys_getsid(td, &bsd));
 1781 }
 1782 
 1783 int
 1784 linux_nosys(struct thread *td, struct nosys_args *ignore)
 1785 {
 1786 
 1787         return (ENOSYS);
 1788 }
 1789 
 1790 int
 1791 linux_getpriority(struct thread *td, struct linux_getpriority_args *args)
 1792 {
 1793         struct getpriority_args bsd_args;
 1794         int error;
 1795 
 1796 #ifdef DEBUG
 1797         if (ldebug(getpriority))
 1798                 printf(ARGS(getpriority, "%i, %i"), args->which, args->who);
 1799 #endif
 1800 
 1801         bsd_args.which = args->which;
 1802         bsd_args.who = args->who;
 1803         error = sys_getpriority(td, &bsd_args);
 1804         td->td_retval[0] = 20 - td->td_retval[0];
 1805         return (error);
 1806 }
 1807 
 1808 int
 1809 linux_sethostname(struct thread *td, struct linux_sethostname_args *args)
 1810 {
 1811         int name[2];
 1812 
 1813 #ifdef DEBUG
 1814         if (ldebug(sethostname))
 1815                 printf(ARGS(sethostname, "*, %i"), args->len);
 1816 #endif
 1817 
 1818         name[0] = CTL_KERN;
 1819         name[1] = KERN_HOSTNAME;
 1820         return (userland_sysctl(td, name, 2, 0, 0, 0, args->hostname,
 1821             args->len, 0, 0));
 1822 }
 1823 
 1824 int
 1825 linux_setdomainname(struct thread *td, struct linux_setdomainname_args *args)
 1826 {
 1827         int name[2];
 1828 
 1829 #ifdef DEBUG
 1830         if (ldebug(setdomainname))
 1831                 printf(ARGS(setdomainname, "*, %i"), args->len);
 1832 #endif
 1833 
 1834         name[0] = CTL_KERN;
 1835         name[1] = KERN_NISDOMAINNAME;
 1836         return (userland_sysctl(td, name, 2, 0, 0, 0, args->name,
 1837             args->len, 0, 0));
 1838 }
 1839 
 1840 int
 1841 linux_exit_group(struct thread *td, struct linux_exit_group_args *args)
 1842 {
 1843 
 1844 #ifdef DEBUG
 1845         if (ldebug(exit_group))
 1846                 printf(ARGS(exit_group, "%i"), args->error_code);
 1847 #endif
 1848 
 1849         LINUX_CTR2(exit_group, "thread(%d) (%d)", td->td_tid,
 1850             args->error_code);
 1851 
 1852         /*
 1853          * XXX: we should send a signal to the parent if
 1854          * SIGNAL_EXIT_GROUP is set. We ignore that (temporarily?)
 1855          * as it doesnt occur often.
 1856          */
 1857         exit1(td, args->error_code, 0);
 1858                 /* NOTREACHED */
 1859 }
 1860 
 1861 #define _LINUX_CAPABILITY_VERSION  0x19980330
 1862 
 1863 struct l_user_cap_header {
 1864         l_int   version;
 1865         l_int   pid;
 1866 };
 1867 
 1868 struct l_user_cap_data {
 1869         l_int   effective;
 1870         l_int   permitted;
 1871         l_int   inheritable;
 1872 };
 1873 
 1874 int
 1875 linux_capget(struct thread *td, struct linux_capget_args *args)
 1876 {
 1877         struct l_user_cap_header luch;
 1878         struct l_user_cap_data lucd;
 1879         int error;
 1880 
 1881         if (args->hdrp == NULL)
 1882                 return (EFAULT);
 1883 
 1884         error = copyin(args->hdrp, &luch, sizeof(luch));
 1885         if (error != 0)
 1886                 return (error);
 1887 
 1888         if (luch.version != _LINUX_CAPABILITY_VERSION) {
 1889                 luch.version = _LINUX_CAPABILITY_VERSION;
 1890                 error = copyout(&luch, args->hdrp, sizeof(luch));
 1891                 if (error)
 1892                         return (error);
 1893                 return (EINVAL);
 1894         }
 1895 
 1896         if (luch.pid)
 1897                 return (EPERM);
 1898 
 1899         if (args->datap) {
 1900                 /*
 1901                  * The current implementation doesn't support setting
 1902                  * a capability (it's essentially a stub) so indicate
 1903                  * that no capabilities are currently set or available
 1904                  * to request.
 1905                  */
 1906                 bzero (&lucd, sizeof(lucd));
 1907                 error = copyout(&lucd, args->datap, sizeof(lucd));
 1908         }
 1909 
 1910         return (error);
 1911 }
 1912 
 1913 int
 1914 linux_capset(struct thread *td, struct linux_capset_args *args)
 1915 {
 1916         struct l_user_cap_header luch;
 1917         struct l_user_cap_data lucd;
 1918         int error;
 1919 
 1920         if (args->hdrp == NULL || args->datap == NULL)
 1921                 return (EFAULT);
 1922 
 1923         error = copyin(args->hdrp, &luch, sizeof(luch));
 1924         if (error != 0)
 1925                 return (error);
 1926 
 1927         if (luch.version != _LINUX_CAPABILITY_VERSION) {
 1928                 luch.version = _LINUX_CAPABILITY_VERSION;
 1929                 error = copyout(&luch, args->hdrp, sizeof(luch));
 1930                 if (error)
 1931                         return (error);
 1932                 return (EINVAL);
 1933         }
 1934 
 1935         if (luch.pid)
 1936                 return (EPERM);
 1937 
 1938         error = copyin(args->datap, &lucd, sizeof(lucd));
 1939         if (error != 0)
 1940                 return (error);
 1941 
 1942         /* We currently don't support setting any capabilities. */
 1943         if (lucd.effective || lucd.permitted || lucd.inheritable) {
 1944                 linux_msg(td,
 1945                           "capset effective=0x%x, permitted=0x%x, "
 1946                           "inheritable=0x%x is not implemented",
 1947                           (int)lucd.effective, (int)lucd.permitted,
 1948                           (int)lucd.inheritable);
 1949                 return (EPERM);
 1950         }
 1951 
 1952         return (0);
 1953 }
 1954 
 1955 int
 1956 linux_prctl(struct thread *td, struct linux_prctl_args *args)
 1957 {
 1958         int error = 0, max_size;
 1959         struct proc *p = td->td_proc;
 1960         char comm[LINUX_MAX_COMM_LEN];
 1961         struct linux_emuldata *em;
 1962         int pdeath_signal;
 1963 
 1964 #ifdef DEBUG
 1965         if (ldebug(prctl))
 1966                 printf(ARGS(prctl, "%d, %ju, %ju, %ju, %ju"), args->option,
 1967                     (uintmax_t)args->arg2, (uintmax_t)args->arg3,
 1968                     (uintmax_t)args->arg4, (uintmax_t)args->arg5);
 1969 #endif
 1970 
 1971         switch (args->option) {
 1972         case LINUX_PR_SET_PDEATHSIG:
 1973                 if (!LINUX_SIG_VALID(args->arg2))
 1974                         return (EINVAL);
 1975                 em = em_find(td);
 1976                 KASSERT(em != NULL, ("prctl: emuldata not found.\n"));
 1977                 em->pdeath_signal = args->arg2;
 1978                 break;
 1979         case LINUX_PR_GET_PDEATHSIG:
 1980                 em = em_find(td);
 1981                 KASSERT(em != NULL, ("prctl: emuldata not found.\n"));
 1982                 pdeath_signal = em->pdeath_signal;
 1983                 error = copyout(&pdeath_signal,
 1984                     (void *)(register_t)args->arg2,
 1985                     sizeof(pdeath_signal));
 1986                 break;
 1987         case LINUX_PR_GET_KEEPCAPS:
 1988                 /*
 1989                  * Indicate that we always clear the effective and
 1990                  * permitted capability sets when the user id becomes
 1991                  * non-zero (actually the capability sets are simply
 1992                  * always zero in the current implementation).
 1993                  */
 1994                 td->td_retval[0] = 0;
 1995                 break;
 1996         case LINUX_PR_SET_KEEPCAPS:
 1997                 /*
 1998                  * Ignore requests to keep the effective and permitted
 1999                  * capability sets when the user id becomes non-zero.
 2000                  */
 2001                 break;
 2002         case LINUX_PR_SET_NAME:
 2003                 /*
 2004                  * To be on the safe side we need to make sure to not
 2005                  * overflow the size a linux program expects. We already
 2006                  * do this here in the copyin, so that we don't need to
 2007                  * check on copyout.
 2008                  */
 2009                 max_size = MIN(sizeof(comm), sizeof(p->p_comm));
 2010                 error = copyinstr((void *)(register_t)args->arg2, comm,
 2011                     max_size, NULL);
 2012 
 2013                 /* Linux silently truncates the name if it is too long. */
 2014                 if (error == ENAMETOOLONG) {
 2015                         /*
 2016                          * XXX: copyinstr() isn't documented to populate the
 2017                          * array completely, so do a copyin() to be on the
 2018                          * safe side. This should be changed in case
 2019                          * copyinstr() is changed to guarantee this.
 2020                          */
 2021                         error = copyin((void *)(register_t)args->arg2, comm,
 2022                             max_size - 1);
 2023                         comm[max_size - 1] = '\0';
 2024                 }
 2025                 if (error)
 2026                         return (error);
 2027 
 2028                 PROC_LOCK(p);
 2029                 strlcpy(p->p_comm, comm, sizeof(p->p_comm));
 2030                 PROC_UNLOCK(p);
 2031                 break;
 2032         case LINUX_PR_GET_NAME:
 2033                 PROC_LOCK(p);
 2034                 strlcpy(comm, p->p_comm, sizeof(comm));
 2035                 PROC_UNLOCK(p);
 2036                 error = copyout(comm, (void *)(register_t)args->arg2,
 2037                     strlen(comm) + 1);
 2038                 break;
 2039         default:
 2040                 error = EINVAL;
 2041                 break;
 2042         }
 2043 
 2044         return (error);
 2045 }
 2046 
 2047 int
 2048 linux_sched_setparam(struct thread *td,
 2049     struct linux_sched_setparam_args *uap)
 2050 {
 2051         struct sched_param sched_param;
 2052         struct thread *tdt;
 2053         int error;
 2054 
 2055 #ifdef DEBUG
 2056         if (ldebug(sched_setparam))
 2057                 printf(ARGS(sched_setparam, "%d, *"), uap->pid);
 2058 #endif
 2059 
 2060         error = copyin(uap->param, &sched_param, sizeof(sched_param));
 2061         if (error)
 2062                 return (error);
 2063 
 2064         tdt = linux_tdfind(td, uap->pid, -1);
 2065         if (tdt == NULL)
 2066                 return (ESRCH);
 2067 
 2068         error = kern_sched_setparam(td, tdt, &sched_param);
 2069         PROC_UNLOCK(tdt->td_proc);
 2070         return (error);
 2071 }
 2072 
 2073 int
 2074 linux_sched_getparam(struct thread *td,
 2075     struct linux_sched_getparam_args *uap)
 2076 {
 2077         struct sched_param sched_param;
 2078         struct thread *tdt;
 2079         int error;
 2080 
 2081 #ifdef DEBUG
 2082         if (ldebug(sched_getparam))
 2083                 printf(ARGS(sched_getparam, "%d, *"), uap->pid);
 2084 #endif
 2085 
 2086         tdt = linux_tdfind(td, uap->pid, -1);
 2087         if (tdt == NULL)
 2088                 return (ESRCH);
 2089 
 2090         error = kern_sched_getparam(td, tdt, &sched_param);
 2091         PROC_UNLOCK(tdt->td_proc);
 2092         if (error == 0)
 2093                 error = copyout(&sched_param, uap->param,
 2094                     sizeof(sched_param));
 2095         return (error);
 2096 }
 2097 
 2098 /*
 2099  * Get affinity of a process.
 2100  */
 2101 int
 2102 linux_sched_getaffinity(struct thread *td,
 2103     struct linux_sched_getaffinity_args *args)
 2104 {
 2105         int error;
 2106         struct thread *tdt;
 2107         struct cpuset_getaffinity_args cga;
 2108 
 2109 #ifdef DEBUG
 2110         if (ldebug(sched_getaffinity))
 2111                 printf(ARGS(sched_getaffinity, "%d, %d, *"), args->pid,
 2112                     args->len);
 2113 #endif
 2114         if (args->len < sizeof(cpuset_t))
 2115                 return (EINVAL);
 2116 
 2117         tdt = linux_tdfind(td, args->pid, -1);
 2118         if (tdt == NULL)
 2119                 return (ESRCH);
 2120 
 2121         PROC_UNLOCK(tdt->td_proc);
 2122         cga.level = CPU_LEVEL_WHICH;
 2123         cga.which = CPU_WHICH_TID;
 2124         cga.id = tdt->td_tid;
 2125         cga.cpusetsize = sizeof(cpuset_t);
 2126         cga.mask = (cpuset_t *) args->user_mask_ptr;
 2127 
 2128         if ((error = sys_cpuset_getaffinity(td, &cga)) == 0)
 2129                 td->td_retval[0] = sizeof(cpuset_t);
 2130 
 2131         return (error);
 2132 }
 2133 
 2134 /*
 2135  *  Set affinity of a process.
 2136  */
 2137 int
 2138 linux_sched_setaffinity(struct thread *td,
 2139     struct linux_sched_setaffinity_args *args)
 2140 {
 2141         struct cpuset_setaffinity_args csa;
 2142         struct thread *tdt;
 2143 
 2144 #ifdef DEBUG
 2145         if (ldebug(sched_setaffinity))
 2146                 printf(ARGS(sched_setaffinity, "%d, %d, *"), args->pid,
 2147                     args->len);
 2148 #endif
 2149         if (args->len < sizeof(cpuset_t))
 2150                 return (EINVAL);
 2151 
 2152         tdt = linux_tdfind(td, args->pid, -1);
 2153         if (tdt == NULL)
 2154                 return (ESRCH);
 2155 
 2156         PROC_UNLOCK(tdt->td_proc);
 2157         csa.level = CPU_LEVEL_WHICH;
 2158         csa.which = CPU_WHICH_TID;
 2159         csa.id = tdt->td_tid;
 2160         csa.cpusetsize = sizeof(cpuset_t);
 2161         csa.mask = (cpuset_t *) args->user_mask_ptr;
 2162 
 2163         return (sys_cpuset_setaffinity(td, &csa));
 2164 }
 2165 
 2166 struct linux_rlimit64 {
 2167         uint64_t        rlim_cur;
 2168         uint64_t        rlim_max;
 2169 };
 2170 
 2171 int
 2172 linux_prlimit64(struct thread *td, struct linux_prlimit64_args *args)
 2173 {
 2174         struct rlimit rlim, nrlim;
 2175         struct linux_rlimit64 lrlim;
 2176         struct proc *p;
 2177         u_int which;
 2178         int flags;
 2179         int error;
 2180 
 2181 #ifdef DEBUG
 2182         if (ldebug(prlimit64))
 2183                 printf(ARGS(prlimit64, "%d, %d, %p, %p"), args->pid,
 2184                     args->resource, (void *)args->new, (void *)args->old);
 2185 #endif
 2186 
 2187         if (args->resource >= LINUX_RLIM_NLIMITS)
 2188                 return (EINVAL);
 2189 
 2190         which = linux_to_bsd_resource[args->resource];
 2191         if (which == -1)
 2192                 return (EINVAL);
 2193 
 2194         if (args->new != NULL) {
 2195                 /*
 2196                  * Note. Unlike FreeBSD where rlim is signed 64-bit Linux
 2197                  * rlim is unsigned 64-bit. FreeBSD treats negative limits
 2198                  * as INFINITY so we do not need a conversion even.
 2199                  */
 2200                 error = copyin(args->new, &nrlim, sizeof(nrlim));
 2201                 if (error != 0)
 2202                         return (error);
 2203         }
 2204 
 2205         flags = PGET_HOLD | PGET_NOTWEXIT;
 2206         if (args->new != NULL)
 2207                 flags |= PGET_CANDEBUG;
 2208         else
 2209                 flags |= PGET_CANSEE;
 2210         error = pget(args->pid, flags, &p);
 2211         if (error != 0)
 2212                 return (error);
 2213 
 2214         if (args->old != NULL) {
 2215                 PROC_LOCK(p);
 2216                 lim_rlimit_proc(p, which, &rlim);
 2217                 PROC_UNLOCK(p);
 2218                 if (rlim.rlim_cur == RLIM_INFINITY)
 2219                         lrlim.rlim_cur = LINUX_RLIM_INFINITY;
 2220                 else
 2221                         lrlim.rlim_cur = rlim.rlim_cur;
 2222                 if (rlim.rlim_max == RLIM_INFINITY)
 2223                         lrlim.rlim_max = LINUX_RLIM_INFINITY;
 2224                 else
 2225                         lrlim.rlim_max = rlim.rlim_max;
 2226                 error = copyout(&lrlim, args->old, sizeof(lrlim));
 2227                 if (error != 0)
 2228                         goto out;
 2229         }
 2230 
 2231         if (args->new != NULL)
 2232                 error = kern_proc_setrlimit(td, p, which, &nrlim);
 2233 
 2234  out:
 2235         PRELE(p);
 2236         return (error);
 2237 }
 2238 
 2239 int
 2240 linux_pselect6(struct thread *td, struct linux_pselect6_args *args)
 2241 {
 2242         struct timeval utv, tv0, tv1, *tvp;
 2243         struct l_pselect6arg lpse6;
 2244         struct l_timespec lts;
 2245         struct timespec uts;
 2246         l_sigset_t l_ss;
 2247         sigset_t *ssp;
 2248         sigset_t ss;
 2249         int error;
 2250 
 2251         ssp = NULL;
 2252         if (args->sig != NULL) {
 2253                 error = copyin(args->sig, &lpse6, sizeof(lpse6));
 2254                 if (error != 0)
 2255                         return (error);
 2256                 if (lpse6.ss_len != sizeof(l_ss))
 2257                         return (EINVAL);
 2258                 if (lpse6.ss != 0) {
 2259                         error = copyin(PTRIN(lpse6.ss), &l_ss,
 2260                             sizeof(l_ss));
 2261                         if (error != 0)
 2262                                 return (error);
 2263                         linux_to_bsd_sigset(&l_ss, &ss);
 2264                         ssp = &ss;
 2265                 }
 2266         }
 2267 
 2268         /*
 2269          * Currently glibc changes nanosecond number to microsecond.
 2270          * This mean losing precision but for now it is hardly seen.
 2271          */
 2272         if (args->tsp != NULL) {
 2273                 error = copyin(args->tsp, &lts, sizeof(lts));
 2274                 if (error != 0)
 2275                         return (error);
 2276                 error = linux_to_native_timespec(&uts, &lts);
 2277                 if (error != 0)
 2278                         return (error);
 2279 
 2280                 TIMESPEC_TO_TIMEVAL(&utv, &uts);
 2281                 if (itimerfix(&utv))
 2282                         return (EINVAL);
 2283 
 2284                 microtime(&tv0);
 2285                 tvp = &utv;
 2286         } else
 2287                 tvp = NULL;
 2288 
 2289         error = kern_pselect(td, args->nfds, args->readfds, args->writefds,
 2290             args->exceptfds, tvp, ssp, LINUX_NFDBITS);
 2291 
 2292         if (error == 0 && args->tsp != NULL) {
 2293                 if (td->td_retval[0] != 0) {
 2294                         /*
 2295                          * Compute how much time was left of the timeout,
 2296                          * by subtracting the current time and the time
 2297                          * before we started the call, and subtracting
 2298                          * that result from the user-supplied value.
 2299                          */
 2300 
 2301                         microtime(&tv1);
 2302                         timevalsub(&tv1, &tv0);
 2303                         timevalsub(&utv, &tv1);
 2304                         if (utv.tv_sec < 0)
 2305                                 timevalclear(&utv);
 2306                 } else
 2307                         timevalclear(&utv);
 2308 
 2309                 TIMEVAL_TO_TIMESPEC(&utv, &uts);
 2310 
 2311                 native_to_linux_timespec(&lts, &uts);
 2312                 error = copyout(&lts, args->tsp, sizeof(lts));
 2313         }
 2314 
 2315         return (error);
 2316 }
 2317 
 2318 int
 2319 linux_ppoll(struct thread *td, struct linux_ppoll_args *args)
 2320 {
 2321         struct timespec ts0, ts1;
 2322         struct l_timespec lts;
 2323         struct timespec uts, *tsp;
 2324         l_sigset_t l_ss;
 2325         sigset_t *ssp;
 2326         sigset_t ss;
 2327         int error;
 2328 
 2329         if (args->sset != NULL) {
 2330                 if (args->ssize != sizeof(l_ss))
 2331                         return (EINVAL);
 2332                 error = copyin(args->sset, &l_ss, sizeof(l_ss));
 2333                 if (error)
 2334                         return (error);
 2335                 linux_to_bsd_sigset(&l_ss, &ss);
 2336                 ssp = &ss;
 2337         } else
 2338                 ssp = NULL;
 2339         if (args->tsp != NULL) {
 2340                 error = copyin(args->tsp, &lts, sizeof(lts));
 2341                 if (error)
 2342                         return (error);
 2343                 error = linux_to_native_timespec(&uts, &lts);
 2344                 if (error != 0)
 2345                         return (error);
 2346 
 2347                 nanotime(&ts0);
 2348                 tsp = &uts;
 2349         } else
 2350                 tsp = NULL;
 2351 
 2352         error = kern_poll(td, args->fds, args->nfds, tsp, ssp);
 2353 
 2354         if (error == 0 && args->tsp != NULL) {
 2355                 if (td->td_retval[0]) {
 2356                         nanotime(&ts1);
 2357                         timespecsub(&ts1, &ts0);
 2358                         timespecsub(&uts, &ts1);
 2359                         if (uts.tv_sec < 0)
 2360                                 timespecclear(&uts);
 2361                 } else
 2362                         timespecclear(&uts);
 2363 
 2364                 native_to_linux_timespec(&lts, &uts);
 2365                 error = copyout(&lts, args->tsp, sizeof(lts));
 2366         }
 2367 
 2368         return (error);
 2369 }
 2370 
 2371 #if defined(DEBUG) || defined(KTR)
 2372 /* XXX: can be removed when every ldebug(...) and KTR stuff are removed. */
 2373 
 2374 #ifdef COMPAT_LINUX32
 2375 #define L_MAXSYSCALL    LINUX32_SYS_MAXSYSCALL
 2376 #else
 2377 #define L_MAXSYSCALL    LINUX_SYS_MAXSYSCALL
 2378 #endif
 2379 
 2380 u_char linux_debug_map[howmany(L_MAXSYSCALL, sizeof(u_char))];
 2381 
 2382 static int
 2383 linux_debug(int syscall, int toggle, int global)
 2384 {
 2385 
 2386         if (global) {
 2387                 char c = toggle ? 0 : 0xff;
 2388 
 2389                 memset(linux_debug_map, c, sizeof(linux_debug_map));
 2390                 return (0);
 2391         }
 2392         if (syscall < 0 || syscall >= L_MAXSYSCALL)
 2393                 return (EINVAL);
 2394         if (toggle)
 2395                 clrbit(linux_debug_map, syscall);
 2396         else
 2397                 setbit(linux_debug_map, syscall);
 2398         return (0);
 2399 }
 2400 #undef L_MAXSYSCALL
 2401 
 2402 /*
 2403  * Usage: sysctl linux.debug=<syscall_nr>.<0/1>
 2404  *
 2405  *    E.g.: sysctl linux.debug=21.0
 2406  *
 2407  * As a special case, syscall "all" will apply to all syscalls globally.
 2408  */
 2409 #define LINUX_MAX_DEBUGSTR      16
 2410 int
 2411 linux_sysctl_debug(SYSCTL_HANDLER_ARGS)
 2412 {
 2413         char value[LINUX_MAX_DEBUGSTR], *p;
 2414         int error, sysc, toggle;
 2415         int global = 0;
 2416 
 2417         value[0] = '\0';
 2418         error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req);
 2419         if (error || req->newptr == NULL)
 2420                 return (error);
 2421         for (p = value; *p != '\0' && *p != '.'; p++);
 2422         if (*p == '\0')
 2423                 return (EINVAL);
 2424         *p++ = '\0';
 2425         sysc = strtol(value, NULL, 0);
 2426         toggle = strtol(p, NULL, 0);
 2427         if (strcmp(value, "all") == 0)
 2428                 global = 1;
 2429         error = linux_debug(sysc, toggle, global);
 2430         return (error);
 2431 }
 2432 
 2433 #endif /* DEBUG || KTR */
 2434 
 2435 int
 2436 linux_sched_rr_get_interval(struct thread *td,
 2437     struct linux_sched_rr_get_interval_args *uap)
 2438 {
 2439         struct timespec ts;
 2440         struct l_timespec lts;
 2441         struct thread *tdt;
 2442         int error;
 2443 
 2444         /*
 2445          * According to man in case the invalid pid specified
 2446          * EINVAL should be returned.
 2447          */
 2448         if (uap->pid < 0)
 2449                 return (EINVAL);
 2450 
 2451         tdt = linux_tdfind(td, uap->pid, -1);
 2452         if (tdt == NULL)
 2453                 return (ESRCH);
 2454 
 2455         error = kern_sched_rr_get_interval_td(td, tdt, &ts);
 2456         PROC_UNLOCK(tdt->td_proc);
 2457         if (error != 0)
 2458                 return (error);
 2459         native_to_linux_timespec(&lts, &ts);
 2460         return (copyout(&lts, uap->interval, sizeof(lts)));
 2461 }
 2462 
 2463 /*
 2464  * In case when the Linux thread is the initial thread in
 2465  * the thread group thread id is equal to the process id.
 2466  * Glibc depends on this magic (assert in pthread_getattr_np.c).
 2467  */
 2468 struct thread *
 2469 linux_tdfind(struct thread *td, lwpid_t tid, pid_t pid)
 2470 {
 2471         struct linux_emuldata *em;
 2472         struct thread *tdt;
 2473         struct proc *p;
 2474 
 2475         tdt = NULL;
 2476         if (tid == 0 || tid == td->td_tid) {
 2477                 tdt = td;
 2478                 PROC_LOCK(tdt->td_proc);
 2479         } else if (tid > PID_MAX)
 2480                 tdt = tdfind(tid, pid);
 2481         else {
 2482                 /*
 2483                  * Initial thread where the tid equal to the pid.
 2484                  */
 2485                 p = pfind(tid);
 2486                 if (p != NULL) {
 2487                         if (SV_PROC_ABI(p) != SV_ABI_LINUX) {
 2488                                 /*
 2489                                  * p is not a Linuxulator process.
 2490                                  */
 2491                                 PROC_UNLOCK(p);
 2492                                 return (NULL);
 2493                         }
 2494                         FOREACH_THREAD_IN_PROC(p, tdt) {
 2495                                 em = em_find(tdt);
 2496                                 if (tid == em->em_tid)
 2497                                         return (tdt);
 2498                         }
 2499                         PROC_UNLOCK(p);
 2500                 }
 2501                 return (NULL);
 2502         }
 2503 
 2504         return (tdt);
 2505 }
 2506 
 2507 void
 2508 linux_to_bsd_waitopts(int options, int *bsdopts)
 2509 {
 2510 
 2511         if (options & LINUX_WNOHANG)
 2512                 *bsdopts |= WNOHANG;
 2513         if (options & LINUX_WUNTRACED)
 2514                 *bsdopts |= WUNTRACED;
 2515         if (options & LINUX_WEXITED)
 2516                 *bsdopts |= WEXITED;
 2517         if (options & LINUX_WCONTINUED)
 2518                 *bsdopts |= WCONTINUED;
 2519         if (options & LINUX_WNOWAIT)
 2520                 *bsdopts |= WNOWAIT;
 2521 
 2522         if (options & __WCLONE)
 2523                 *bsdopts |= WLINUXCLONE;
 2524 }

Cache object: cb3c7ab5a9a4df022e5d8175fec00fff


[ 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.