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