compat/linux/linux

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
linux_to_bsd_rlimit
linux_sys_setrlimit
linux_dogetrlimit
linux_sys_getrlimit
linux_sys_ugetrlimit
    1 /*      $OpenBSD: linux_resource.c,v 1.4 2003/06/03 20:49:28 deraadt Exp $      */
    2 
    3 /*
    4  * Copyright (c) 2000 Niklas Hallqvist
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   26  */
   27 
   28 /*
   29  * Linux "resource" syscall emulation
   30  */
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 #include <sys/mount.h>
   35 #include <sys/proc.h>
   36 #include <sys/resource.h>
   37 #include <sys/resourcevar.h>
   38 #include <sys/syscallargs.h>
   39 
   40 #include <compat/linux/linux_types.h>
   41 #include <compat/linux/linux_resource.h>
   42 #include <compat/linux/linux_signal.h>
   43 #include <compat/linux/linux_syscallargs.h>
   44 
   45 /* linux_resource.c */
   46 int     linux_to_bsd_rlimit(u_int);
   47 int     linux_dogetrlimit(struct proc *, void *, register_t *, rlim_t);
   48 
   49 static u_int linux_to_bsd_rlimit_map[] = {
   50         RLIMIT_CPU,
   51         RLIMIT_FSIZE,
   52         RLIMIT_DATA,
   53         RLIMIT_STACK,
   54         RLIMIT_CORE,
   55         RLIMIT_RSS,
   56         RLIMIT_NPROC,
   57         RLIMIT_NOFILE,
   58         RLIMIT_MEMLOCK,
   59         RLIM_NLIMITS            /* LINUX_RLIMIT_AS not supported */
   60 };
   61 
   62 int
   63 linux_to_bsd_rlimit(which)
   64         u_int which;
   65 {
   66         if (which >= LINUX_RLIM_NLIMITS)
   67                 return (RLIM_NLIMITS);
   68         return (linux_to_bsd_rlimit_map[which]);
   69 }
   70 
   71 int
   72 linux_sys_setrlimit(p, v, retval)
   73         struct proc *p;
   74         void *v;
   75         register_t *retval;
   76 {
   77         struct linux_sys_setrlimit_args /* {
   78                 syscallarg(u_int) which;
   79                 syscallarg(struct linux_rlimit *) rlp;
   80         } */ *uap = v;
   81 
   82         SCARG(uap, which) = linux_to_bsd_rlimit(SCARG(uap, which));
   83         if (SCARG(uap, which) == RLIM_NLIMITS)
   84                 return (EINVAL);
   85         return (compat_43_sys_setrlimit(p, v, retval));
   86 }
   87 
   88 int
   89 linux_dogetrlimit(p, v, retval, max)
   90         struct proc *p;
   91         void *v;
   92         register_t *retval;
   93         rlim_t max;
   94 {
   95         struct linux_sys_getrlimit_args /* {
   96                 syscallarg(u_int) which;
   97                 syscallarg(struct linux_rlimit *) rlp;
   98         } */ *uap = v;
   99         u_int which;
  100         struct linux_rlimit rlim;
  101 
  102         which = linux_to_bsd_rlimit(SCARG(uap, which));
  103         if (which == RLIM_NLIMITS)
  104                 return (EINVAL);
  105 
  106         rlim.rlim_cur = MIN(p->p_rlimit[which].rlim_cur, max);
  107         rlim.rlim_max = MIN(p->p_rlimit[which].rlim_max, max);
  108         return (copyout(&rlim, SCARG(uap, rlp), sizeof rlim));
  109 }
  110 
  111 int
  112 linux_sys_getrlimit(p, v, retval)
  113         struct proc *p;
  114         void *v;
  115         register_t *retval;
  116 {
  117         return (linux_dogetrlimit(p, v, retval, LINUX_OLD_RLIM_INFINITY));
  118 }
  119 
  120 int
  121 linux_sys_ugetrlimit(p, v, retval)
  122         struct proc *p;
  123         void *v;
  124         register_t *retval;
  125 {
  126         return (linux_dogetrlimit(p, v, retval, LINUX_RLIM_INFINITY));
  127 }
/* [<][>][^][v][top][bottom][index][help] */
root/compat/linux/linux_resource.c

DEFINITIONS
