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


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

FreeBSD/Linux Kernel Cross Reference
sys/compat/svr4/svr4_resource.c

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

    1 /*-
    2  * Copyright (c) 1998 The NetBSD Foundation, Inc.
    3  * All rights reserved.
    4  *
    5  * This code is derived from software contributed to The NetBSD Foundation
    6  * by Christos Zoulas.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   21  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   27  * POSSIBILITY OF SUCH DAMAGE.
   28  */
   29 /*-
   30  * Portions of this software have been derived from software contributed
   31  * to the FreeBSD Project by Mark Newton.
   32  *
   33  * Copyright (c) 1999 Mark Newton
   34  * All rights reserved.
   35  * 
   36  * Redistribution and use in source and binary forms, with or without
   37  * modification, are permitted provided that the following conditions
   38  * are met:
   39  * 1. Redistributions of source code must retain the above copyright
   40  *    notice, this list of conditions and the following disclaimer.
   41  * 2. Redistributions in binary form must reproduce the above copyright
   42  *    notice, this list of conditions and the following disclaimer in the
   43  *    documentation and/or other materials provided with the distribution.
   44  * 3. The name of the author may not be used to endorse or promote products
   45  *    derived from this software without specific prior written permission
   46  *
   47  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   48  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   49  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   50  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   51  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   52  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   53  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   54  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   55  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   56  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   57  *
   58  * Derived from: $NetBSD: svr4_resource.c,v 1.3 1998/12/13 18:00:52 christos Exp $
   59  */
   60 
   61 #include <sys/cdefs.h>
   62 __FBSDID("$FreeBSD: releng/11.2/sys/compat/svr4/svr4_resource.c 284215 2015-06-10 10:48:12Z mjg $");
   63 
   64 #include <sys/param.h>
   65 #include <sys/systm.h>
   66 #include <sys/file.h>
   67 #include <sys/lock.h>
   68 #include <sys/mutex.h>
   69 #include <sys/proc.h>
   70 #include <sys/resource.h>
   71 #include <sys/resourcevar.h>
   72 #include <sys/syscallsubr.h>
   73 
   74 #include <compat/svr4/svr4.h>
   75 #include <compat/svr4/svr4_types.h>
   76 #include <compat/svr4/svr4_resource.h>
   77 #include <compat/svr4/svr4_signal.h>
   78 #include <compat/svr4/svr4_proto.h>
   79 #include <compat/svr4/svr4_util.h>
   80 
   81 static __inline int svr4_to_native_rl(int);
   82 
   83 static __inline int
   84 svr4_to_native_rl(rl)
   85         int rl;
   86 {
   87         switch (rl) {
   88         case SVR4_RLIMIT_CPU:
   89                 return RLIMIT_CPU;
   90         case SVR4_RLIMIT_FSIZE:
   91                 return RLIMIT_FSIZE;
   92         case SVR4_RLIMIT_DATA:
   93                 return RLIMIT_DATA;
   94         case SVR4_RLIMIT_STACK:
   95                 return RLIMIT_STACK;
   96         case SVR4_RLIMIT_CORE:
   97                 return RLIMIT_CORE;
   98         case SVR4_RLIMIT_NOFILE:
   99                 return RLIMIT_NOFILE;
  100         case SVR4_RLIMIT_VMEM:
  101                 return RLIMIT_VMEM;
  102         default:
  103                 return -1;
  104         }
  105 }
  106 
  107 /*
  108  * Check if the resource limit fits within the BSD range and it is not
  109  * one of the magic SVR4 limit values
  110  */
  111 #define OKLIMIT(l) (((int32_t)(l)) >= 0 && ((int32_t)(l)) < 0x7fffffff && \
  112         ((svr4_rlim_t)(l)) != SVR4_RLIM_INFINITY && \
  113         ((svr4_rlim_t)(l)) != SVR4_RLIM_SAVED_CUR && \
  114         ((svr4_rlim_t)(l)) != SVR4_RLIM_SAVED_MAX)
  115 
  116 #define OKLIMIT64(l) (((rlim_t)(l)) >= 0 && ((rlim_t)(l)) < RLIM_INFINITY && \
  117         ((svr4_rlim64_t)(l)) != SVR4_RLIM64_INFINITY && \
  118         ((svr4_rlim64_t)(l)) != SVR4_RLIM64_SAVED_CUR && \
  119         ((svr4_rlim64_t)(l)) != SVR4_RLIM64_SAVED_MAX)
  120 
  121 int
  122 svr4_sys_getrlimit(td, uap)
  123         struct thread *td;
  124         struct svr4_sys_getrlimit_args *uap;
  125 {
  126         int rl = svr4_to_native_rl(uap->which);
  127         struct rlimit blim;
  128         struct svr4_rlimit slim;
  129 
  130         if (rl == -1)
  131                 return EINVAL;
  132 
  133         lim_rlimit(td, rl, &blim);
  134 
  135         /*
  136          * Our infinity, is their maxfiles.
  137          */
  138         if (rl == RLIMIT_NOFILE && blim.rlim_max == RLIM_INFINITY)
  139                 blim.rlim_max = maxfiles;
  140 
  141         /*
  142          * If the limit can be be represented, it is returned.
  143          * Otherwise, if rlim_cur == rlim_max, return RLIM_SAVED_MAX
  144          * else return RLIM_SAVED_CUR
  145          */
  146         if (blim.rlim_max == RLIM_INFINITY)
  147                 slim.rlim_max = SVR4_RLIM_INFINITY;
  148         else if (OKLIMIT(blim.rlim_max))
  149                 slim.rlim_max = (svr4_rlim_t) blim.rlim_max;
  150         else
  151                 slim.rlim_max = SVR4_RLIM_SAVED_MAX;
  152 
  153         if (blim.rlim_cur == RLIM_INFINITY)
  154                 slim.rlim_cur = SVR4_RLIM_INFINITY;
  155         else if (OKLIMIT(blim.rlim_cur))
  156                 slim.rlim_cur = (svr4_rlim_t) blim.rlim_cur;
  157         else if (blim.rlim_max == blim.rlim_cur)
  158                 slim.rlim_cur = SVR4_RLIM_SAVED_MAX;
  159         else
  160                 slim.rlim_cur = SVR4_RLIM_SAVED_CUR;
  161 
  162         return copyout(&slim, uap->rlp, sizeof(*uap->rlp));
  163 }
  164 
  165 
  166 int
  167 svr4_sys_setrlimit(td, uap)
  168         struct thread *td;
  169         struct svr4_sys_setrlimit_args *uap;
  170 {
  171         int rl = svr4_to_native_rl(uap->which);
  172         struct rlimit blim, curlim;
  173         struct svr4_rlimit slim;
  174         int error;
  175 
  176         if (rl == -1)
  177                 return EINVAL;
  178 
  179         if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
  180                 return error;
  181 
  182         lim_rlimit(td, rl, &curlim);
  183 
  184         /*
  185          * if the limit is SVR4_RLIM_INFINITY, then we set it to our
  186          * unlimited.
  187          * We should also: If it is SVR4_RLIM_SAVED_MAX, we should set the
  188          * new limit to the corresponding saved hard limit, and if
  189          * it is equal to SVR4_RLIM_SAVED_CUR, we should set it to the
  190          * corresponding saved soft limit.
  191          *
  192          */
  193         if (slim.rlim_max == SVR4_RLIM_INFINITY)
  194                 blim.rlim_max = RLIM_INFINITY;
  195         else if (OKLIMIT(slim.rlim_max))
  196                 blim.rlim_max = (rlim_t) slim.rlim_max;
  197         else if (slim.rlim_max == SVR4_RLIM_SAVED_MAX)
  198                 blim.rlim_max = curlim.rlim_max;
  199         else if (slim.rlim_max == SVR4_RLIM_SAVED_CUR)
  200                 blim.rlim_max = curlim.rlim_cur;
  201 
  202         if (slim.rlim_cur == SVR4_RLIM_INFINITY)
  203                 blim.rlim_cur = RLIM_INFINITY;
  204         else if (OKLIMIT(slim.rlim_cur))
  205                 blim.rlim_cur = (rlim_t) slim.rlim_cur;
  206         else if (slim.rlim_cur == SVR4_RLIM_SAVED_MAX)
  207                 blim.rlim_cur = curlim.rlim_max;
  208         else if (slim.rlim_cur == SVR4_RLIM_SAVED_CUR)
  209                 blim.rlim_cur = curlim.rlim_cur;
  210 
  211         return (kern_setrlimit(td, rl, &blim));
  212 }
  213 
  214 
  215 int
  216 svr4_sys_getrlimit64(td, uap)
  217         struct thread *td;
  218         struct svr4_sys_getrlimit64_args *uap;
  219 {
  220         int rl = svr4_to_native_rl(uap->which);
  221         struct rlimit blim;
  222         struct svr4_rlimit64 slim;
  223 
  224         if (rl == -1)
  225                 return EINVAL;
  226 
  227         lim_rlimit(td, rl, &blim);
  228 
  229         /*
  230          * Our infinity, is their maxfiles.
  231          */
  232         if (rl == RLIMIT_NOFILE && blim.rlim_max == RLIM_INFINITY)
  233                 blim.rlim_max = maxfiles;
  234 
  235         /*
  236          * If the limit can be be represented, it is returned.
  237          * Otherwise, if rlim_cur == rlim_max, return SVR4_RLIM_SAVED_MAX
  238          * else return SVR4_RLIM_SAVED_CUR
  239          */
  240         if (blim.rlim_max == RLIM_INFINITY)
  241                 slim.rlim_max = SVR4_RLIM64_INFINITY;
  242         else if (OKLIMIT64(blim.rlim_max))
  243                 slim.rlim_max = (svr4_rlim64_t) blim.rlim_max;
  244         else
  245                 slim.rlim_max = SVR4_RLIM64_SAVED_MAX;
  246 
  247         if (blim.rlim_cur == RLIM_INFINITY)
  248                 slim.rlim_cur = SVR4_RLIM64_INFINITY;
  249         else if (OKLIMIT64(blim.rlim_cur))
  250                 slim.rlim_cur = (svr4_rlim64_t) blim.rlim_cur;
  251         else if (blim.rlim_max == blim.rlim_cur)
  252                 slim.rlim_cur = SVR4_RLIM64_SAVED_MAX;
  253         else
  254                 slim.rlim_cur = SVR4_RLIM64_SAVED_CUR;
  255 
  256         return copyout(&slim, uap->rlp, sizeof(*uap->rlp));
  257 }
  258 
  259 
  260 int
  261 svr4_sys_setrlimit64(td, uap)
  262         struct thread *td;
  263         struct svr4_sys_setrlimit64_args *uap;
  264 {
  265         int rl = svr4_to_native_rl(uap->which);
  266         struct rlimit blim, curlim;
  267         struct svr4_rlimit64 slim;
  268         int error;
  269 
  270         if (rl == -1)
  271                 return EINVAL;
  272 
  273         if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
  274                 return error;
  275 
  276         lim_rlimit(td, rl, &curlim);
  277 
  278         /*
  279          * if the limit is SVR4_RLIM64_INFINITY, then we set it to our
  280          * unlimited.
  281          * We should also: If it is SVR4_RLIM64_SAVED_MAX, we should set the
  282          * new limit to the corresponding saved hard limit, and if
  283          * it is equal to SVR4_RLIM64_SAVED_CUR, we should set it to the
  284          * corresponding saved soft limit.
  285          *
  286          */
  287         if (slim.rlim_max == SVR4_RLIM64_INFINITY)
  288                 blim.rlim_max = RLIM_INFINITY;
  289         else if (OKLIMIT64(slim.rlim_max))
  290                 blim.rlim_max = (rlim_t) slim.rlim_max;
  291         else if (slim.rlim_max == SVR4_RLIM64_SAVED_MAX)
  292                 blim.rlim_max = curlim.rlim_max;
  293         else if (slim.rlim_max == SVR4_RLIM64_SAVED_CUR)
  294                 blim.rlim_max = curlim.rlim_cur;
  295 
  296         if (slim.rlim_cur == SVR4_RLIM64_INFINITY)
  297                 blim.rlim_cur = RLIM_INFINITY;
  298         else if (OKLIMIT64(slim.rlim_cur))
  299                 blim.rlim_cur = (rlim_t) slim.rlim_cur;
  300         else if (slim.rlim_cur == SVR4_RLIM64_SAVED_MAX)
  301                 blim.rlim_cur = curlim.rlim_max;
  302         else if (slim.rlim_cur == SVR4_RLIM64_SAVED_CUR)
  303                 blim.rlim_cur = curlim.rlim_cur;
  304 
  305         return (kern_setrlimit(td, rl, &blim));
  306 }

Cache object: 37da5e490dba42a0ae9175ccf850d581


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


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