sys/emulation/linux/linux_misc.c

   1 /*-
   2  * Copyright (c) 1994-1995 Søren Schmidt
   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 withough 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  * $FreeBSD: src/sys/compat/linux/linux_misc.c,v 1.85.2.9 2002/09/24 08:11:41 mdodd Exp $
  29  * $DragonFly: src/sys/emulation/linux/linux_misc.c,v 1.39 2007/06/26 19:31:03 dillon Exp $
  30  */
  31
  32 #include "opt_compat.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/fcntl.h>
  37 #include <sys/imgact_aout.h>
  38 #include <sys/kernel.h>
  39 #include <sys/kern_syscall.h>
  40 #include <sys/lock.h>
  41 #include <sys/mman.h>
  42 #include <sys/mount.h>
  43 #include <sys/poll.h>
  44 #include <sys/proc.h>
  45 #include <sys/priv.h>
  46 #include <sys/nlookup.h>
  47 #include <sys/blist.h>
  48 #include <sys/reboot.h>
  49 #include <sys/resourcevar.h>
  50 #include <sys/signalvar.h>
  51 #include <sys/signal2.h>
  52 #include <sys/stat.h>
  53 #include <sys/sysctl.h>
  54 #include <sys/sysproto.h>
  55 #include <sys/time.h>
  56 #include <sys/unistd.h>
  57 #include <sys/vmmeter.h>
  58 #include <sys/vnode.h>
  59 #include <sys/wait.h>
  60 #include <sys/thread2.h>
  61
  62 #include <vm/vm.h>
  63 #include <vm/pmap.h>
  64 #include <vm/vm_kern.h>
  65 #include <vm/vm_map.h>
  66 #include <vm/vm_extern.h>
  67 #include <vm/vm_object.h>
  68 #include <vm/vm_zone.h>
  69 #include <vm/swap_pager.h>
  70
  71 #include <machine/frame.h>
  72 #include <machine/limits.h>
  73 #include <machine/psl.h>
  74 #include <machine/sysarch.h>
  75 #ifdef __i386__
  76 #include <machine/segments.h>
  77 #endif
  78
  79 #include <sys/sched.h>
  80
  81 #include <emulation/linux/linux_sysproto.h>
  82 #include <arch_linux/linux.h>
  83 #include <arch_linux/linux_proto.h>
  84 #include "linux_mib.h"
  85 #include "linux_util.h"
  86
  87 #define BSD_TO_LINUX_SIGNAL(sig)        \
  88         (((sig) <= LINUX_SIGTBLSZ) ? bsd_to_linux_signal[_SIG_IDX(sig)] : sig)
  89
  90 static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = {
  91         RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK,
  92         RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE,
  93         RLIMIT_MEMLOCK, -1
  94 };
  95
  96 struct l_sysinfo {
  97         l_long          uptime;         /* Seconds since boot */
  98         l_ulong         loads[3];       /* 1, 5, and 15 minute load averages */
  99         l_ulong         totalram;       /* Total usable main memory size */
 100         l_ulong         freeram;        /* Available memory size */
 101         l_ulong         sharedram;      /* Amount of shared memory */
 102         l_ulong         bufferram;      /* Memory used by buffers */
 103         l_ulong         totalswap;      /* Total swap space size */
 104         l_ulong         freeswap;       /* swap space still available */
 105         l_ushort        procs;          /* Number of current processes */
 106         char            _f[22];         /* Pads structure to 64 bytes */
 107 };
 108
 109 /*
 110  * MPALMOSTSAFE
 111  */
 112 int
 113 sys_linux_sysinfo(struct linux_sysinfo_args *args)
 114 {
 115         struct l_sysinfo sysinfo;
 116         vm_object_t object;
 117         struct timespec ts;
 118         int error;
 119         int i;
 120
 121         /* Uptime is copied out of print_uptime() in kern_shutdown.c */
 122         getnanouptime(&ts);
 123         i = 0;
 124         if (ts.tv_sec >= 86400) {
 125                 ts.tv_sec %= 86400;
 126                 i = 1;
 127         }
 128         if (i || ts.tv_sec >= 3600) {
 129                 ts.tv_sec %= 3600;
 130                 i = 1;
 131         }
 132         if (i || ts.tv_sec >= 60) {
 133                 ts.tv_sec %= 60;
 134                 i = 1;
 135         }
 136         sysinfo.uptime=ts.tv_sec;
 137
 138         /* Use the information from the mib to get our load averages */
 139         for (i = 0; i < 3; i++)
 140                 sysinfo.loads[i] = averunnable.ldavg[i];
 141
 142         sysinfo.totalram = Maxmem * PAGE_SIZE;
 143         sysinfo.freeram = sysinfo.totalram - vmstats.v_wire_count * PAGE_SIZE;
 144
 145         get_mplock();
 146         sysinfo.sharedram = 0;
 147         for (object = TAILQ_FIRST(&vm_object_list); object != NULL;
 148              object = TAILQ_NEXT(object, object_list))
 149                 if (object->shadow_count > 1)
 150                         sysinfo.sharedram += object->resident_page_count;
 151
 152         sysinfo.sharedram *= PAGE_SIZE;
 153         sysinfo.bufferram = 0;
 154
 155         if (swapblist == NULL) {
 156                 sysinfo.totalswap= 0;
 157                 sysinfo.freeswap = 0;
 158         } else {
 159                 sysinfo.totalswap = swapblist->bl_blocks * 1024;
 160                 sysinfo.freeswap = swapblist->bl_root->u.bmu_avail * PAGE_SIZE;
 161         }
 162         rel_mplock();
 163
 164         sysinfo.procs = 20; /* Hack */
 165
 166         error = copyout(&sysinfo, (caddr_t)args->info, sizeof(sysinfo));
 167         return (error);
 168 }
 169
 170 /*
 171  * MPALMOSTSAFE
 172  */
 173 int
 174 sys_linux_alarm(struct linux_alarm_args *args)
 175 {
 176         struct thread *td = curthread;
 177         struct proc *p = td->td_proc;
 178         struct itimerval it, old_it;
 179         struct timeval tv;
 180
 181 #ifdef DEBUG
 182         if (ldebug(alarm))
 183                 kprintf(ARGS(alarm, "%u"), args->secs);
 184 #endif
 185
 186         if (args->secs > 100000000)
 187                 return EINVAL;
 188
 189         it.it_value.tv_sec = (long)args->secs;
 190         it.it_value.tv_usec = 0;
 191         it.it_interval.tv_sec = 0;
 192         it.it_interval.tv_usec = 0;
 193         get_mplock();
 194         crit_enter();
 195         old_it = p->p_realtimer;
 196         getmicrouptime(&tv);
 197         if (timevalisset(&old_it.it_value))
 198                 callout_stop(&p->p_ithandle);
 199         if (it.it_value.tv_sec != 0) {
 200                 callout_reset(&p->p_ithandle, tvtohz_high(&it.it_value),
 201                              realitexpire, p);
 202                 timevaladd(&it.it_value, &tv);
 203         }
 204         p->p_realtimer = it;
 205         crit_exit();
 206         rel_mplock();
 207         if (timevalcmp(&old_it.it_value, &tv, >)) {
 208                 timevalsub(&old_it.it_value, &tv);
 209                 if (old_it.it_value.tv_usec != 0)
 210                         old_it.it_value.tv_sec++;
 211                 args->sysmsg_result = old_it.it_value.tv_sec;
 212         }
 213         return 0;
 214 }
 215
 216 /*
 217  * MPALMOSTSAFE
 218  */
 219 int
 220 sys_linux_brk(struct linux_brk_args *args)
 221 {
 222         struct thread *td = curthread;
 223         struct proc *p = td->td_proc;
 224         struct vmspace *vm;
 225         vm_offset_t new, old;
 226         struct obreak_args bsd_args;
 227
 228         get_mplock();
 229         vm = p->p_vmspace;
 230 #ifdef DEBUG
 231         if (ldebug(brk))
 232                 kprintf(ARGS(brk, "%p"), (void *)args->dsend);
 233 #endif
 234         old = (vm_offset_t)vm->vm_daddr + ctob(vm->vm_dsize);
 235         new = (vm_offset_t)args->dsend;
 236         bsd_args.sysmsg_result = 0;
 237         bsd_args.nsize = (char *) new;
 238         bsd_args.sysmsg_result = 0;
 239         if (((caddr_t)new > vm->vm_daddr) && !sys_obreak(&bsd_args))
 240                 args->sysmsg_result = (long)new;
 241         else
 242                 args->sysmsg_result = (long)old;
 243         rel_mplock();
 244
 245         return 0;
 246 }
 247
 248 /*
 249  * MPALMOSTSAFE
 250  */
 251 int
 252 sys_linux_uselib(struct linux_uselib_args *args)
 253 {
 254         struct thread *td = curthread;
 255         struct proc *p;
 256         struct nlookupdata nd;
 257         struct vnode *vp;
 258         struct exec *a_out;
 259         struct vattr attr;
 260         vm_offset_t vmaddr;
 261         unsigned long file_offset;
 262         vm_offset_t buffer;
 263         unsigned long bss_size;
 264         int error;
 265         int locked;
 266         char *path;
 267
 268         p = td->td_proc;
 269
 270         error = linux_copyin_path(args->library, &path, LINUX_PATH_EXISTS);
 271         if (error)
 272                 return (error);
 273 #ifdef DEBUG
 274         if (ldebug(uselib))
 275                 kprintf(ARGS(uselib, "%s"), path);
 276 #endif
 277
 278         a_out = NULL;
 279         locked = 0;
 280         vp = NULL;
 281
 282         get_mplock();
 283         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
 284         nd.nl_flags |= NLC_EXEC;
 285         if (error == 0)
 286                 error = nlookup(&nd);
 287         if (error == 0)
 288                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
 289         if (error)
 290                 goto cleanup;
 291         /*
 292          * From here on down, we have a locked vnode that must be unlocked.
 293          */
 294         locked = 1;
 295
 296         /* Writable? */
 297         if (vp->v_writecount) {
 298                 error = ETXTBSY;
 299                 goto cleanup;
 300         }
 301
 302         /* Executable? */
 303         error = VOP_GETATTR(vp, &attr);
 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                 error = ENOEXEC;
 310                 goto cleanup;
 311         }
 312
 313         /* Sensible size? */
 314         if (attr.va_size == 0) {
 315                 error = ENOEXEC;
 316                 goto cleanup;
 317         }
 318
 319         error = VOP_OPEN(vp, FREAD, p->p_ucred, NULL);
 320         if (error)
 321                 goto cleanup;
 322
 323         /*
 324          * Lock no longer needed
 325          */
 326         vn_unlock(vp);
 327         locked = 0;
 328
 329         /* Pull in executable header into kernel_map */
 330         error = vm_mmap(&kernel_map, (vm_offset_t *)&a_out, PAGE_SIZE,
 331             VM_PROT_READ, VM_PROT_READ, 0, (caddr_t)vp, 0);
 332         if (error)
 333                 goto cleanup;
 334
 335         /* Is it a Linux binary ? */
 336         if (((a_out->a_magic >> 16) & 0xff) != 0x64) {
 337                 error = ENOEXEC;
 338                 goto cleanup;
 339         }
 340
 341         /*
 342          * While we are here, we should REALLY do some more checks
 343          */
 344
 345         /* Set file/virtual offset based on a.out variant. */
 346         switch ((int)(a_out->a_magic & 0xffff)) {
 347         case 0413:      /* ZMAGIC */
 348                 file_offset = 1024;
 349                 break;
 350         case 0314:      /* QMAGIC */
 351                 file_offset = 0;
 352                 break;
 353         default:
 354                 error = ENOEXEC;
 355                 goto cleanup;
 356         }
 357
 358         bss_size = round_page(a_out->a_bss);
 359
 360         /* Check various fields in header for validity/bounds. */
 361         if (a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK) {
 362                 error = ENOEXEC;
 363                 goto cleanup;
 364         }
 365
 366         /* text + data can't exceed file size */
 367         if (a_out->a_data + a_out->a_text > attr.va_size) {
 368                 error = EFAULT;
 369                 goto cleanup;
 370         }
 371
 372         /*
 373          * text/data/bss must not exceed limits
 374          * XXX - this is not complete. it should check current usage PLUS
 375          * the resources needed by this library.
 376          */
 377         if (a_out->a_text > maxtsiz ||
 378             a_out->a_data + bss_size > p->p_rlimit[RLIMIT_DATA].rlim_cur) {
 379                 error = ENOMEM;
 380                 goto cleanup;
 381         }
 382
 383         /* prevent more writers */
 384         vp->v_flag |= VTEXT;
 385
 386         /*
 387          * Check if file_offset page aligned. Currently we cannot handle
 388          * misalinged file offsets, and so we read in the entire image
 389          * (what a waste).
 390          */
 391         if (file_offset & PAGE_MASK) {
 392 #ifdef DEBUG
 393                 kprintf("uselib: Non page aligned binary %lu\n", file_offset);
 394 #endif
 395                 /* Map text+data read/write/execute */
 396
 397                 /* a_entry is the load address and is page aligned */
 398                 vmaddr = trunc_page(a_out->a_entry);
 399
 400                 /* get anon user mapping, read+write+execute */
 401                 error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0,
 402                                     &vmaddr, a_out->a_text + a_out->a_data,
 403                                     FALSE,
 404                                     VM_MAPTYPE_NORMAL,
 405                                     VM_PROT_ALL, VM_PROT_ALL,
 406                                     0);
 407                 if (error)
 408                         goto cleanup;
 409
 410                 /* map file into kernel_map */
 411                 error = vm_mmap(&kernel_map, &buffer,
 412                     round_page(a_out->a_text + a_out->a_data + file_offset),
 413                     VM_PROT_READ, VM_PROT_READ, 0, (caddr_t)vp,
 414                     trunc_page(file_offset));
 415                 if (error)
 416                         goto cleanup;
 417
 418                 /* copy from kernel VM space to user space */
 419                 error = copyout((caddr_t)(uintptr_t)(buffer + file_offset),
 420                     (caddr_t)vmaddr, a_out->a_text + a_out->a_data);
 421
 422                 /* release temporary kernel space */
 423                 vm_map_remove(&kernel_map, buffer, buffer +
 424                     round_page(a_out->a_text + a_out->a_data + file_offset));
 425
 426                 if (error)
 427                         goto cleanup;
 428         } else {
 429 #ifdef DEBUG
 430                 kprintf("uselib: Page aligned binary %lu\n", file_offset);
 431 #endif
 432                 /*
 433                  * for QMAGIC, a_entry is 20 bytes beyond the load address
 434                  * to skip the executable header
 435                  */
 436                 vmaddr = trunc_page(a_out->a_entry);
 437
 438                 /*
 439                  * Map it all into the process's space as a single
 440                  * copy-on-write "data" segment.
 441                  */
 442                 error = vm_mmap(&p->p_vmspace->vm_map, &vmaddr,
 443                     a_out->a_text + a_out->a_data, VM_PROT_ALL, VM_PROT_ALL,
 444                     MAP_PRIVATE | MAP_FIXED, (caddr_t)vp, file_offset);
 445                 if (error)
 446                         goto cleanup;
 447         }
 448 #ifdef DEBUG
 449         kprintf("mem=%08lx = %08lx %08lx\n", (long)vmaddr, ((long*)vmaddr)[0],
 450             ((long*)vmaddr)[1]);
 451 #endif
 452         if (bss_size != 0) {
 453                 /* Calculate BSS start address */
 454                 vmaddr = trunc_page(a_out->a_entry) + a_out->a_text +
 455                     a_out->a_data;
 456
 457                 /* allocate some 'anon' space */
 458                 error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0,
 459                                     &vmaddr, bss_size,
 460                                     FALSE,
 461                                     VM_MAPTYPE_NORMAL,
 462                                     VM_PROT_ALL, VM_PROT_ALL,
 463                                     0);
 464                 if (error)
 465                         goto cleanup;
 466         }
 467
 468 cleanup:
 469         /* Unlock/release vnode */
 470         if (vp) {
 471                 if (locked)
 472                         vn_unlock(vp);
 473                 vrele(vp);
 474         }
 475         /* Release the kernel mapping. */
 476         if (a_out) {
 477                 vm_map_remove(&kernel_map, (vm_offset_t)a_out,
 478                     (vm_offset_t)a_out + PAGE_SIZE);
 479         }
 480         nlookup_done(&nd);
 481         rel_mplock();
 482         linux_free_path(&path);
 483         return (error);
 484 }
 485
 486 /*
 487  * MPSAFE
 488  */
 489 int
 490 sys_linux_select(struct linux_select_args *args)
 491 {
 492         struct select_args bsa;
 493         struct timeval tv0, tv1, utv, *tvp;
 494         caddr_t sg;
 495         int error;
 496
 497 #ifdef DEBUG
 498         if (ldebug(select))
 499                 kprintf(ARGS(select, "%d, %p, %p, %p, %p"), args->nfds,
 500                     (void *)args->readfds, (void *)args->writefds,
 501                     (void *)args->exceptfds, (void *)args->timeout);
 502 #endif
 503
 504         error = 0;
 505         bsa.sysmsg_result = 0;
 506         bsa.nd = args->nfds;
 507         bsa.in = args->readfds;
 508         bsa.ou = args->writefds;
 509         bsa.ex = args->exceptfds;
 510         bsa.tv = (struct timeval *)args->timeout;
 511
 512         /*
 513          * Store current time for computation of the amount of
 514          * time left.
 515          */
 516         if (args->timeout) {
 517                 if ((error = copyin((caddr_t)args->timeout, &utv,
 518                     sizeof(utv))))
 519                         goto select_out;
 520 #ifdef DEBUG
 521                 if (ldebug(select))
 522                         kprintf(LMSG("incoming timeout (%ld/%ld)"),
 523                             utv.tv_sec, utv.tv_usec);
 524 #endif
 525
 526                 if (itimerfix(&utv)) {
 527                         /*
 528                          * The timeval was invalid.  Convert it to something
 529                          * valid that will act as it does under Linux.
 530                          */
 531                         sg = stackgap_init();
 532                         tvp = stackgap_alloc(&sg, sizeof(utv));
 533                         utv.tv_sec += utv.tv_usec / 1000000;
 534                         utv.tv_usec %= 1000000;
 535                         if (utv.tv_usec < 0) {
 536                                 utv.tv_sec -= 1;
 537                                 utv.tv_usec += 1000000;
 538                         }
 539                         if (utv.tv_sec < 0)
 540                                 timevalclear(&utv);
 541                         if ((error = copyout(&utv, tvp, sizeof(utv))))
 542                                 goto select_out;
 543                         bsa.tv = tvp;
 544                 }
 545                 microtime(&tv0);
 546         }
 547
 548         error = sys_select(&bsa);
 549         args->sysmsg_result = bsa.sysmsg_result;
 550 #ifdef DEBUG
 551         if (ldebug(select))
 552                 kprintf(LMSG("real select returns %d"), error);
 553 #endif
 554         if (error) {
 555                 /*
 556                  * See fs/select.c in the Linux kernel.  Without this,
 557                  * Maelstrom doesn't work.
 558                  */
 559                 if (error == ERESTART)
 560                         error = EINTR;
 561                 goto select_out;
 562         }
 563
 564         if (args->timeout) {
 565                 if (args->sysmsg_result) {
 566                         /*
 567                          * Compute how much time was left of the timeout,
 568                          * by subtracting the current time and the time
 569                          * before we started the call, and subtracting
 570                          * that result from the user-supplied value.
 571                          */
 572                         microtime(&tv1);
 573                         timevalsub(&tv1, &tv0);
 574                         timevalsub(&utv, &tv1);
 575                         if (utv.tv_sec < 0)
 576                                 timevalclear(&utv);
 577                 } else
 578                         timevalclear(&utv);
 579 #ifdef DEBUG
 580                 if (ldebug(select))
 581                         kprintf(LMSG("outgoing timeout (%ld/%ld)"),
 582                             utv.tv_sec, utv.tv_usec);
 583 #endif
 584                 if ((error = copyout(&utv, (caddr_t)args->timeout,
 585                     sizeof(utv))))
 586                         goto select_out;
 587         }
 588
 589 select_out:
 590 #ifdef DEBUG
 591         if (ldebug(select))
 592                 kprintf(LMSG("select_out -> %d"), error);
 593 #endif
 594         return error;
 595 }
 596
 597 /*
 598  * MPSAFE
 599  */
 600 int
 601 sys_linux_mremap(struct linux_mremap_args *args)
 602 {
 603         struct munmap_args bsd_args;
 604         int error = 0;
 605
 606 #ifdef DEBUG
 607         if (ldebug(mremap))
 608                 kprintf(ARGS(mremap, "%p, %08lx, %08lx, %08lx"),
 609                     (void *)args->addr,
 610                     (unsigned long)args->old_len,
 611                     (unsigned long)args->new_len,
 612                     (unsigned long)args->flags);
 613 #endif
 614         args->new_len = round_page(args->new_len);
 615         args->old_len = round_page(args->old_len);
 616
 617         if (args->new_len > args->old_len) {
 618                 args->sysmsg_result = 0;
 619                 return ENOMEM;
 620         }
 621
 622         if (args->new_len < args->old_len) {
 623                 bsd_args.sysmsg_result = 0;
 624                 bsd_args.addr = (caddr_t)(args->addr + args->new_len);
 625                 bsd_args.len = args->old_len - args->new_len;
 626                 error = sys_munmap(&bsd_args);
 627         }
 628
 629         args->sysmsg_resultp = error ? NULL : (void *)args->addr;
 630         return error;
 631 }
 632
 633 #define LINUX_MS_ASYNC          0x0001
 634 #define LINUX_MS_INVALIDATE     0x0002
 635 #define LINUX_MS_SYNC           0x0004
 636
 637 /*
 638  * MPSAFE
 639  */
 640 int
 641 sys_linux_msync(struct linux_msync_args *args)
 642 {
 643         struct msync_args bsd_args;
 644         int error;
 645
 646         bsd_args.addr = (caddr_t)args->addr;
 647         bsd_args.len = args->len;
 648         bsd_args.flags = args->fl & ~LINUX_MS_SYNC;
 649         bsd_args.sysmsg_result = 0;
 650
 651         error = sys_msync(&bsd_args);
 652         args->sysmsg_result = bsd_args.sysmsg_result;
 653         return(error);
 654 }
 655
 656 /*
 657  * MPSAFE
 658  */
 659 int
 660 sys_linux_time(struct linux_time_args *args)
 661 {
 662         struct timeval tv;
 663         l_time_t tm;
 664         int error;
 665
 666 #ifdef DEBUG
 667         if (ldebug(time))
 668                 kprintf(ARGS(time, "*"));
 669 #endif
 670
 671         microtime(&tv);
 672         tm = tv.tv_sec;
 673         if (args->tm && (error = copyout(&tm, (caddr_t)args->tm, sizeof(tm))))
 674                 return error;
 675         args->sysmsg_lresult = tm;
 676         return 0;
 677 }
 678
 679 struct l_times_argv {
 680         l_long          tms_utime;
 681         l_long          tms_stime;
 682         l_long          tms_cutime;
 683         l_long          tms_cstime;
 684 };
 685
 686 #define CLK_TCK 100     /* Linux uses 100 */
 687
 688 #define CONVTCK(r)      (r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK))
 689
 690 /*
 691  * MPALMOSTSAFE
 692  */
 693 int
 694 sys_linux_times(struct linux_times_args *args)
 695 {
 696         struct thread *td = curthread;
 697         struct proc *p = td->td_proc;
 698         struct timeval tv;
 699         struct l_times_argv tms;
 700         struct rusage ru;
 701         int error;
 702
 703 #ifdef DEBUG
 704         if (ldebug(times))
 705                 kprintf(ARGS(times, "*"));
 706 #endif
 707
 708         get_mplock();
 709         calcru_proc(p, &ru);
 710         rel_mplock();
 711
 712         tms.tms_utime = CONVTCK(ru.ru_utime);
 713         tms.tms_stime = CONVTCK(ru.ru_stime);
 714
 715         tms.tms_cutime = CONVTCK(p->p_cru.ru_utime);
 716         tms.tms_cstime = CONVTCK(p->p_cru.ru_stime);
 717
 718         if ((error = copyout(&tms, (caddr_t)args->buf, sizeof(tms))))
 719                 return error;
 720
 721         microuptime(&tv);
 722         args->sysmsg_result = (int)CONVTCK(tv);
 723         return 0;
 724 }
 725
 726 /*
 727  * MPALMOSTSAFE
 728  */
 729 int
 730 sys_linux_newuname(struct linux_newuname_args *args)
 731 {
 732         struct thread *td = curthread;
 733         struct l_new_utsname utsname;
 734         char *osrelease, *osname;
 735
 736 #ifdef DEBUG
 737         if (ldebug(newuname))
 738                 kprintf(ARGS(newuname, "*"));
 739 #endif
 740
 741         get_mplock();
 742         osname = linux_get_osname(td);
 743         osrelease = linux_get_osrelease(td);
 744
 745         bzero(&utsname, sizeof(utsname));
 746         strncpy(utsname.sysname, osname, LINUX_MAX_UTSNAME-1);
 747         strncpy(utsname.nodename, hostname, LINUX_MAX_UTSNAME-1);
 748         strncpy(utsname.release, osrelease, LINUX_MAX_UTSNAME-1);
 749         strncpy(utsname.version, version, LINUX_MAX_UTSNAME-1);
 750         strncpy(utsname.machine, machine, LINUX_MAX_UTSNAME-1);
 751         strncpy(utsname.domainname, domainname, LINUX_MAX_UTSNAME-1);
 752         rel_mplock();
 753
 754         return (copyout(&utsname, (caddr_t)args->buf, sizeof(utsname)));
 755 }
 756
 757 #if defined(__i386__)
 758 struct l_utimbuf {
 759         l_time_t l_actime;
 760         l_time_t l_modtime;
 761 };
 762
 763 /*
 764  * MPALMOSTSAFE
 765  */
 766 int
 767 sys_linux_utime(struct linux_utime_args *args)
 768 {
 769         struct timeval tv[2];
 770         struct l_utimbuf lut;
 771         struct nlookupdata nd;
 772         char *path;
 773         int error;
 774
 775         error = linux_copyin_path(args->fname, &path, LINUX_PATH_EXISTS);
 776         if (error)
 777                 return (error);
 778 #ifdef DEBUG
 779         if (ldebug(utime))
 780                 kprintf(ARGS(utime, "%s, *"), path);
 781 #endif
 782
 783         if (args->times) {
 784                 error = copyin(args->times, &lut, sizeof(lut));
 785                 if (error)
 786                         goto cleanup;
 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         }
 792         get_mplock();
 793         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
 794         if (error == 0)
 795                 error = kern_utimes(&nd, args->times ? tv : NULL);
 796         nlookup_done(&nd);
 797         rel_mplock();
 798 cleanup:
 799         linux_free_path(&path);
 800         return (error);
 801 }
 802 #endif /* __i386__ */
 803
 804 #define __WCLONE 0x80000000
 805
 806 /*
 807  * MPALMOSTSAFE
 808  */
 809 int
 810 sys_linux_waitpid(struct linux_waitpid_args *args)
 811 {
 812         int error, options, status;
 813
 814 #ifdef DEBUG
 815         if (ldebug(waitpid))
 816                 kprintf(ARGS(waitpid, "%d, %p, %d"),
 817                     args->pid, (void *)args->status, args->options);
 818 #endif
 819         options = args->options & (WNOHANG | WUNTRACED);
 820         /* WLINUXCLONE should be equal to __WCLONE, but we make sure */
 821         if (args->options & __WCLONE)
 822                 options |= WLINUXCLONE;
 823
 824         error = kern_wait(args->pid, args->status ? &status : NULL, options,
 825                           NULL, &args->sysmsg_result);
 826
 827         if (error == 0 && args->status) {
 828                 status &= 0xffff;
 829                 if (WIFSIGNALED(status))
 830                         status = (status & 0xffffff80) |
 831                             BSD_TO_LINUX_SIGNAL(WTERMSIG(status));
 832                 else if (WIFSTOPPED(status))
 833                         status = (status & 0xffff00ff) |
 834                             (BSD_TO_LINUX_SIGNAL(WSTOPSIG(status)) << 8);
 835                 error = copyout(&status, args->status, sizeof(status));
 836         }
 837
 838         return (error);
 839 }
 840
 841 /*
 842  * MPALMOSTSAFE
 843  */
 844 int
 845 sys_linux_wait4(struct linux_wait4_args *args)
 846 {
 847         struct thread *td = curthread;
 848         struct lwp *lp = td->td_lwp;
 849         struct rusage rusage;
 850         int error, options, status;
 851
 852 #ifdef DEBUG
 853         if (ldebug(wait4))
 854                 kprintf(ARGS(wait4, "%d, %p, %d, %p"),
 855                     args->pid, (void *)args->status, args->options,
 856                     (void *)args->rusage);
 857 #endif
 858         options = args->options & (WNOHANG | WUNTRACED);
 859         /* WLINUXCLONE should be equal to __WCLONE, but we make sure */
 860         if (args->options & __WCLONE)
 861                 options |= WLINUXCLONE;
 862
 863         error = kern_wait(args->pid, args->status ? &status : NULL, options,
 864                           args->rusage ? &rusage : NULL, &args->sysmsg_result);
 865
 866         if (error == 0)
 867                 lwp_delsig(lp, SIGCHLD);
 868
 869         if (error == 0 && args->status) {
 870                 status &= 0xffff;
 871                 if (WIFSIGNALED(status))
 872                         status = (status & 0xffffff80) |
 873                             BSD_TO_LINUX_SIGNAL(WTERMSIG(status));
 874                 else if (WIFSTOPPED(status))
 875                         status = (status & 0xffff00ff) |
 876                             (BSD_TO_LINUX_SIGNAL(WSTOPSIG(status)) << 8);
 877                 error = copyout(&status, args->status, sizeof(status));
 878         }
 879         if (error == 0 && args->rusage)
 880                 error = copyout(&rusage, args->rusage, sizeof(rusage));
 881
 882         return (error);
 883 }
 884
 885 /*
 886  * MPALMOSTSAFE
 887  */
 888 int
 889 sys_linux_mknod(struct linux_mknod_args *args)
 890 {
 891         struct nlookupdata nd;
 892         char *path;
 893         int error;
 894
 895         error = linux_copyin_path(args->path, &path, LINUX_PATH_CREATE);
 896         if (error)
 897                 return (error);
 898 #ifdef DEBUG
 899         if (ldebug(mknod))
 900                 kprintf(ARGS(mknod, "%s, %d, %d"),
 901                     path, args->mode, args->dev);
 902 #endif
 903         get_mplock();
 904         error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
 905         if (error == 0) {
 906                 if (args->mode & S_IFIFO) {
 907                         error = kern_mkfifo(&nd, args->mode);
 908                 } else {
 909                         error = kern_mknod(&nd, args->mode,
 910                                            umajor(args->dev),
 911                                            uminor(args->dev));
 912                 }
 913         }
 914         nlookup_done(&nd);
 915         rel_mplock();
 916
 917         linux_free_path(&path);
 918         return(error);
 919 }
 920
 921 /*
 922  * UGH! This is just about the dumbest idea I've ever heard!!
 923  *
 924  * MPSAFE
 925  */
 926 int
 927 sys_linux_personality(struct linux_personality_args *args)
 928 {
 929 #ifdef DEBUG
 930         if (ldebug(personality))
 931                 kprintf(ARGS(personality, "%d"), args->per);
 932 #endif
 933         if (args->per != 0)
 934                 return EINVAL;
 935
 936         /* Yes Jim, it's still a Linux... */
 937         args->sysmsg_result = 0;
 938         return 0;
 939 }
 940
 941 /*
 942  * Wrappers for get/setitimer for debugging..
 943  *
 944  * MPSAFE
 945  */
 946 int
 947 sys_linux_setitimer(struct linux_setitimer_args *args)
 948 {
 949         struct setitimer_args bsa;
 950         struct itimerval foo;
 951         int error;
 952
 953 #ifdef DEBUG
 954         if (ldebug(setitimer))
 955                 kprintf(ARGS(setitimer, "%p, %p"),
 956                     (void *)args->itv, (void *)args->oitv);
 957 #endif
 958         bsa.which = args->which;
 959         bsa.itv = (struct itimerval *)args->itv;
 960         bsa.oitv = (struct itimerval *)args->oitv;
 961         bsa.sysmsg_result = 0;
 962         if (args->itv) {
 963             if ((error = copyin((caddr_t)args->itv, &foo, sizeof(foo))))
 964                 return error;
 965 #ifdef DEBUG
 966             if (ldebug(setitimer)) {
 967                 kprintf("setitimer: value: sec: %ld, usec: %ld\n",
 968                     foo.it_value.tv_sec, foo.it_value.tv_usec);
 969                 kprintf("setitimer: interval: sec: %ld, usec: %ld\n",
 970                     foo.it_interval.tv_sec, foo.it_interval.tv_usec);
 971             }
 972 #endif
 973         }
 974         error = sys_setitimer(&bsa);
 975         args->sysmsg_result = bsa.sysmsg_result;
 976         return(error);
 977 }
 978
 979 /*
 980  * MPSAFE
 981  */
 982 int
 983 sys_linux_getitimer(struct linux_getitimer_args *args)
 984 {
 985         struct getitimer_args bsa;
 986         int error;
 987 #ifdef DEBUG
 988         if (ldebug(getitimer))
 989                 kprintf(ARGS(getitimer, "%p"), (void *)args->itv);
 990 #endif
 991         bsa.which = args->which;
 992         bsa.itv = (struct itimerval *)args->itv;
 993         bsa.sysmsg_result = 0;
 994         error = sys_getitimer(&bsa);
 995         args->sysmsg_result = bsa.sysmsg_result;
 996         return(error);
 997 }
 998
 999 /*
1000  * MPSAFE
1001  */
1002 int
1003 sys_linux_nice(struct linux_nice_args *args)
1004 {
1005         struct setpriority_args bsd_args;
1006         int error;
1007
1008         bsd_args.which = PRIO_PROCESS;
1009         bsd_args.who = 0;       /* current process */
1010         bsd_args.prio = args->inc;
1011         bsd_args.sysmsg_result = 0;
1012         error = sys_setpriority(&bsd_args);
1013         args->sysmsg_result = bsd_args.sysmsg_result;
1014         return(error);
1015 }
1016
1017 /*
1018  * MPALMOSTSAFE
1019  */
1020 int
1021 sys_linux_setgroups(struct linux_setgroups_args *args)
1022 {
1023         struct thread *td = curthread;
1024         struct proc *p = td->td_proc;
1025         struct ucred *newcred, *oldcred;
1026         l_gid_t linux_gidset[NGROUPS];
1027         gid_t *bsd_gidset;
1028         int ngrp, error;
1029
1030         ngrp = args->gidsetsize;
1031         oldcred = p->p_ucred;
1032
1033         /*
1034          * cr_groups[0] holds egid. Setting the whole set from
1035          * the supplied set will cause egid to be changed too.
1036          * Keep cr_groups[0] unchanged to prevent that.
1037          */
1038
1039         if ((error = priv_check_cred(oldcred, PRIV_CRED_SETGROUPS, 0)) != 0)
1040                 return (error);
1041
1042         if ((u_int)ngrp >= NGROUPS)
1043                 return (EINVAL);
1044
1045         get_mplock();
1046         newcred = crdup(oldcred);
1047         if (ngrp > 0) {
1048                 error = copyin((caddr_t)args->grouplist, linux_gidset,
1049                                ngrp * sizeof(l_gid_t));
1050                 if (error) {
1051                         crfree(newcred);
1052                         rel_mplock();
1053                         return (error);
1054                 }
1055
1056                 newcred->cr_ngroups = ngrp + 1;
1057
1058                 bsd_gidset = newcred->cr_groups;
1059                 ngrp--;
1060                 while (ngrp >= 0) {
1061                         bsd_gidset[ngrp + 1] = linux_gidset[ngrp];
1062                         ngrp--;
1063                 }
1064         } else {
1065                 newcred->cr_ngroups = 1;
1066         }
1067
1068         setsugid();
1069         p->p_ucred = newcred;
1070         crfree(oldcred);
1071         rel_mplock();
1072         return (0);
1073 }
1074
1075 /*
1076  * MPSAFE
1077  */
1078 int
1079 sys_linux_getgroups(struct linux_getgroups_args *args)
1080 {
1081         struct thread *td = curthread;
1082         struct proc *p = td->td_proc;
1083         struct ucred *cred;
1084         l_gid_t linux_gidset[NGROUPS];
1085         gid_t *bsd_gidset;
1086         int bsd_gidsetsz, ngrp, error;
1087
1088         cred = p->p_ucred;
1089         bsd_gidset = cred->cr_groups;
1090         bsd_gidsetsz = cred->cr_ngroups - 1;
1091
1092         /*
1093          * cr_groups[0] holds egid. Returning the whole set
1094          * here will cause a duplicate. Exclude cr_groups[0]
1095          * to prevent that.
1096          */
1097
1098         if ((ngrp = args->gidsetsize) == 0) {
1099                 args->sysmsg_result = bsd_gidsetsz;
1100                 return (0);
1101         }
1102
1103         if ((u_int)ngrp < bsd_gidsetsz)
1104                 return (EINVAL);
1105
1106         ngrp = 0;
1107         while (ngrp < bsd_gidsetsz) {
1108                 linux_gidset[ngrp] = bsd_gidset[ngrp + 1];
1109                 ngrp++;
1110         }
1111
1112         if ((error = copyout(linux_gidset, args->grouplist,
1113                              ngrp * sizeof(l_gid_t)))) {
1114                 return (error);
1115         }
1116
1117         args->sysmsg_result = ngrp;
1118         return (0);
1119 }
1120
1121 /*
1122  * MPSAFE
1123  */
1124 int
1125 sys_linux_setrlimit(struct linux_setrlimit_args *args)
1126 {
1127         struct l_rlimit linux_rlim;
1128         struct rlimit rlim;
1129         u_int which;
1130         int error;
1131
1132 #ifdef DEBUG
1133         if (ldebug(setrlimit))
1134                 kprintf(ARGS(setrlimit, "%d, %p"),
1135                     args->resource, (void *)args->rlim);
1136 #endif
1137         if (args->resource >= LINUX_RLIM_NLIMITS)
1138                 return (EINVAL);
1139         which = linux_to_bsd_resource[args->resource];
1140         if (which == -1)
1141                 return (EINVAL);
1142
1143         error = copyin(args->rlim, &linux_rlim, sizeof(linux_rlim));
1144         if (error)
1145                 return (error);
1146         rlim.rlim_cur = (rlim_t)linux_rlim.rlim_cur;
1147         rlim.rlim_max = (rlim_t)linux_rlim.rlim_max;
1148
1149         error = kern_setrlimit(which, &rlim);
1150
1151         return(error);
1152 }
1153
1154 /*
1155  * MPSAFE
1156  */
1157 int
1158 sys_linux_old_getrlimit(struct linux_old_getrlimit_args *args)
1159 {
1160         struct l_rlimit linux_rlim;
1161         struct rlimit rlim;
1162         u_int which;
1163         int error;
1164
1165 #ifdef DEBUG
1166         if (ldebug(old_getrlimit))
1167                 kprintf(ARGS(old_getrlimit, "%d, %p"),
1168                     args->resource, (void *)args->rlim);
1169 #endif
1170         if (args->resource >= LINUX_RLIM_NLIMITS)
1171                 return (EINVAL);
1172         which = linux_to_bsd_resource[args->resource];
1173         if (which == -1)
1174                 return (EINVAL);
1175
1176         error = kern_getrlimit(which, &rlim);
1177
1178         if (error == 0) {
1179                 linux_rlim.rlim_cur = (l_ulong)rlim.rlim_cur;
1180                 if (linux_rlim.rlim_cur == ULONG_MAX)
1181                         linux_rlim.rlim_cur = LONG_MAX;
1182                 linux_rlim.rlim_max = (l_ulong)rlim.rlim_max;
1183                 if (linux_rlim.rlim_max == ULONG_MAX)
1184                         linux_rlim.rlim_max = LONG_MAX;
1185                 error = copyout(&linux_rlim, args->rlim, sizeof(linux_rlim));
1186         }
1187         return (error);
1188 }
1189
1190 /*
1191  * MPSAFE
1192  */
1193 int
1194 sys_linux_getrlimit(struct linux_getrlimit_args *args)
1195 {
1196         struct l_rlimit linux_rlim;
1197         struct rlimit rlim;
1198         u_int which;
1199         int error;
1200
1201 #ifdef DEBUG
1202         if (ldebug(getrlimit))
1203                 kprintf(ARGS(getrlimit, "%d, %p"),
1204                     args->resource, (void *)args->rlim);
1205 #endif
1206         if (args->resource >= LINUX_RLIM_NLIMITS)
1207                 return (EINVAL);
1208         which = linux_to_bsd_resource[args->resource];
1209         if (which == -1)
1210                 return (EINVAL);
1211
1212         error = kern_getrlimit(which, &rlim);
1213
1214         if (error == 0) {
1215                 linux_rlim.rlim_cur = (l_ulong)rlim.rlim_cur;
1216                 linux_rlim.rlim_max = (l_ulong)rlim.rlim_max;
1217                 error = copyout(&linux_rlim, args->rlim, sizeof(linux_rlim));
1218         }
1219         return (error);
1220 }
1221
1222 /*
1223  * MPSAFE
1224  */
1225 int
1226 sys_linux_sched_setscheduler(struct linux_sched_setscheduler_args *args)
1227 {
1228         struct sched_setscheduler_args bsd;
1229         int error;
1230
1231 #ifdef DEBUG
1232         if (ldebug(sched_setscheduler))
1233                 kprintf(ARGS(sched_setscheduler, "%d, %d, %p"),
1234                     args->pid, args->policy, (const void *)args->param);
1235 #endif
1236
1237         switch (args->policy) {
1238         case LINUX_SCHED_OTHER:
1239                 bsd.policy = SCHED_OTHER;
1240                 break;
1241         case LINUX_SCHED_FIFO:
1242                 bsd.policy = SCHED_FIFO;
1243                 break;
1244         case LINUX_SCHED_RR:
1245                 bsd.policy = SCHED_RR;
1246                 break;
1247         default:
1248                 return EINVAL;
1249         }
1250
1251         bsd.pid = args->pid;
1252         bsd.param = (struct sched_param *)args->param;
1253         bsd.sysmsg_result = 0;
1254
1255         error = sys_sched_setscheduler(&bsd);
1256         args->sysmsg_result = bsd.sysmsg_result;
1257         return(error);
1258 }
1259
1260 /*
1261  * MPSAFE
1262  */
1263 int
1264 sys_linux_sched_getscheduler(struct linux_sched_getscheduler_args *args)
1265 {
1266         struct sched_getscheduler_args bsd;
1267         int error;
1268
1269 #ifdef DEBUG
1270         if (ldebug(sched_getscheduler))
1271                 kprintf(ARGS(sched_getscheduler, "%d"), args->pid);
1272 #endif
1273
1274         bsd.sysmsg_result = 0;
1275         bsd.pid = args->pid;
1276         error = sys_sched_getscheduler(&bsd);
1277         args->sysmsg_result = bsd.sysmsg_result;
1278
1279         switch (args->sysmsg_result) {
1280         case SCHED_OTHER:
1281                 args->sysmsg_result = LINUX_SCHED_OTHER;
1282                 break;
1283         case SCHED_FIFO:
1284                 args->sysmsg_result = LINUX_SCHED_FIFO;
1285                 break;
1286         case SCHED_RR:
1287                 args->sysmsg_result = LINUX_SCHED_RR;
1288                 break;
1289         }
1290         return error;
1291 }
1292
1293 /*
1294  * MPSAFE
1295  */
1296 int
1297 sys_linux_sched_get_priority_max(struct linux_sched_get_priority_max_args *args)
1298 {
1299         struct sched_get_priority_max_args bsd;
1300         int error;
1301
1302 #ifdef DEBUG
1303         if (ldebug(sched_get_priority_max))
1304                 kprintf(ARGS(sched_get_priority_max, "%d"), args->policy);
1305 #endif
1306
1307         switch (args->policy) {
1308         case LINUX_SCHED_OTHER:
1309                 bsd.policy = SCHED_OTHER;
1310                 break;
1311         case LINUX_SCHED_FIFO:
1312                 bsd.policy = SCHED_FIFO;
1313                 break;
1314         case LINUX_SCHED_RR:
1315                 bsd.policy = SCHED_RR;
1316                 break;
1317         default:
1318                 return EINVAL;
1319         }
1320         bsd.sysmsg_result = 0;
1321
1322         error = sys_sched_get_priority_max(&bsd);
1323         args->sysmsg_result = bsd.sysmsg_result;
1324         return(error);
1325 }
1326
1327 /*
1328  * MPSAFE
1329  */
1330 int
1331 sys_linux_sched_get_priority_min(struct linux_sched_get_priority_min_args *args)
1332 {
1333         struct sched_get_priority_min_args bsd;
1334         int error;
1335
1336 #ifdef DEBUG
1337         if (ldebug(sched_get_priority_min))
1338                 kprintf(ARGS(sched_get_priority_min, "%d"), args->policy);
1339 #endif
1340
1341         switch (args->policy) {
1342         case LINUX_SCHED_OTHER:
1343                 bsd.policy = SCHED_OTHER;
1344                 break;
1345         case LINUX_SCHED_FIFO:
1346                 bsd.policy = SCHED_FIFO;
1347                 break;
1348         case LINUX_SCHED_RR:
1349                 bsd.policy = SCHED_RR;
1350                 break;
1351         default:
1352                 return EINVAL;
1353         }
1354         bsd.sysmsg_result = 0;
1355
1356         error = sys_sched_get_priority_min(&bsd);
1357         args->sysmsg_result = bsd.sysmsg_result;
1358         return(error);
1359 }
1360
1361 #define REBOOT_CAD_ON   0x89abcdef
1362 #define REBOOT_CAD_OFF  0
1363 #define REBOOT_HALT     0xcdef0123
1364
1365 /*
1366  * MPSAFE
1367  */
1368 int
1369 sys_linux_reboot(struct linux_reboot_args *args)
1370 {
1371         struct reboot_args bsd_args;
1372         int error;
1373
1374 #ifdef DEBUG
1375         if (ldebug(reboot))
1376                 kprintf(ARGS(reboot, "0x%x"), args->cmd);
1377 #endif
1378         if (args->cmd == REBOOT_CAD_ON || args->cmd == REBOOT_CAD_OFF)
1379                 return (0);
1380         bsd_args.opt = (args->cmd == REBOOT_HALT) ? RB_HALT : 0;
1381         bsd_args.sysmsg_result = 0;
1382
1383         error = sys_reboot(&bsd_args);
1384         args->sysmsg_result = bsd_args.sysmsg_result;
1385         return(error);
1386 }
1387
1388 /*
1389  * The FreeBSD native getpid(2), getgid(2) and getuid(2) also modify
1390  * p->p_retval[1] when COMPAT_43 or COMPAT_SUNOS is defined. This
1391  * globbers registers that are assumed to be preserved. The following
1392  * lightweight syscalls fixes this. See also linux_getgid16() and
1393  * linux_getuid16() in linux_uid16.c.
1394  *
1395  * linux_getpid() - MP SAFE
1396  * linux_getgid() - MP SAFE
1397  * linux_getuid() - MP SAFE
1398  */
1399
1400 /*
1401  * MPSAFE
1402  */
1403 int
1404 sys_linux_getpid(struct linux_getpid_args *args)
1405 {
1406         struct thread *td = curthread;
1407         struct proc *p = td->td_proc;
1408
1409         args->sysmsg_result = p->p_pid;
1410         return (0);
1411 }
1412
1413 /*
1414  * MPSAFE
1415  */
1416 int
1417 sys_linux_getgid(struct linux_getgid_args *args)
1418 {
1419         struct thread *td = curthread;
1420         struct proc *p = td->td_proc;
1421
1422         args->sysmsg_result = p->p_ucred->cr_rgid;
1423         return (0);
1424 }
1425
1426 /*
1427  * MPSAFE
1428  */
1429 int
1430 sys_linux_getuid(struct linux_getuid_args *args)
1431 {
1432         struct thread *td = curthread;
1433         struct proc *p = td->td_proc;
1434
1435         args->sysmsg_result = p->p_ucred->cr_ruid;
1436         return (0);
1437 }
1438
1439 /*
1440  * MPSAFE
1441  */
1442 int
1443 sys_linux_getsid(struct linux_getsid_args *args)
1444 {
1445         struct getsid_args bsd;
1446         int error;
1447
1448         bsd.sysmsg_result = 0;
1449         bsd.pid = args->pid;
1450         error = sys_getsid(&bsd);
1451         args->sysmsg_result = bsd.sysmsg_result;
1452         return(error);
1453 }
1454
1455 /*
1456  * MPSAFE
1457  */
1458 int
1459 linux_nosys(struct nosys_args *args)
1460 {
1461         /* XXX */
1462         return (ENOSYS);
1463 }