/*      $NetBSD: netbsd32_rlimit.c,v 1.2 2021/01/19 03:20:13 simonb Exp $       */

/*
* Copyright (c) 1998, 2001, 2008, 2018 Matthew R. Green
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: NetBSD: netbsd32_netbsd.c,v 1.218 2018/08/10 21:44:58 pgoyette Exp
*/

/* rlimit netbsd32 related code */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: netbsd32_rlimit.c,v 1.2 2021/01/19 03:20:13 simonb Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resource.h>
#include <sys/exec.h>

#include <compat/netbsd32/netbsd32.h>
#include <compat/netbsd32/netbsd32_syscall.h>
#include <compat/netbsd32/netbsd32_syscallargs.h>
#include <compat/netbsd32/netbsd32_conv.h>

#define LIMITCHECK(a, b) ((a) != RLIM_INFINITY && (a) > (b))

static void
fixlimit(int which, struct rlimit *alim)
{
       switch (which) {
       case RLIMIT_DATA:
               if (LIMITCHECK(alim->rlim_cur, MAXDSIZ32))
                       alim->rlim_cur = MAXDSIZ32;
               if (LIMITCHECK(alim->rlim_max, MAXDSIZ32))
                       alim->rlim_max = MAXDSIZ32;
               return;
       case RLIMIT_STACK:
               if (LIMITCHECK(alim->rlim_cur, MAXSSIZ32))
                       alim->rlim_cur = MAXSSIZ32;
               if (LIMITCHECK(alim->rlim_max, MAXSSIZ32))
                       alim->rlim_max = MAXSSIZ32;
               return;
       default:
               return;
       }
}

int
netbsd32_getrlimit(struct lwp *l, const struct netbsd32_getrlimit_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(int) which;
               syscallarg(netbsd32_rlimitp_t) rlp;
       } */
       int which = SCARG(uap, which);
       struct rlimit alim;

       if ((u_int)which >= RLIM_NLIMITS)
               return EINVAL;

       alim = l->l_proc->p_rlimit[which];

       fixlimit(which, &alim);

       return copyout(&alim, SCARG_P32(uap, rlp), sizeof(alim));
}

int
netbsd32_setrlimit(struct lwp *l, const struct netbsd32_setrlimit_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(int) which;
               syscallarg(const netbsd32_rlimitp_t) rlp;
       } */
               int which = SCARG(uap, which);
       struct rlimit alim;
       int error;

       if ((u_int)which >= RLIM_NLIMITS)
               return EINVAL;

       error = copyin(SCARG_P32(uap, rlp), &alim, sizeof(struct rlimit));
       if (error)
               return error;

       fixlimit(which, &alim);

       return dosetrlimit(l, l->l_proc, which, &alim);
}

void
netbsd32_adjust_limits(struct proc *p)
{
       static const struct {
               int id;
               rlim_t lim;
       } lm[] = {
               { RLIMIT_DATA,  MAXDSIZ32 },
               { RLIMIT_STACK, MAXSSIZ32 },
       };
       size_t i;
       struct plimit *lim;
       struct rlimit *rlim;

       /*
        * We can only reduce the current limits, we cannot stop external
        * processes from changing them (eg via sysctl) later on.
        * So there is no point trying to lock out such changes here.
        *
        * If we assume that rlim_cur/max are accessed using atomic
        * operations, we don't need to lock against any other updates
        * that might happen if the plimit structure is shared writable
        * between multiple processes.
        */

       /* Scan to determine is any limits are out of range */
       lim = p->p_limit;
       for (i = 0; ; i++) {
               if (i >= __arraycount(lm))
                       /* All in range */
                       return;
               rlim = lim->pl_rlimit + lm[i].id;
               if (LIMITCHECK(rlim->rlim_cur, lm[i].lim))
                       break;
               if (LIMITCHECK(rlim->rlim_max, lm[i].lim))
                       break;
       }

       lim_privatise(p);

       lim = p->p_limit;
       for (i = 0; i < __arraycount(lm); i++) {
               rlim = lim->pl_rlimit + lm[i].id;
               if (LIMITCHECK(rlim->rlim_cur, lm[i].lim))
                       rlim->rlim_cur = lm[i].lim;
               if (LIMITCHECK(rlim->rlim_max, lm[i].lim))
                       rlim->rlim_max = lm[i].lim;
       }
}