summaryrefslogtreecommitdiffstats
path: root/sys/compat
diff options
context:
space:
mode:
Diffstat (limited to 'sys/compat')
-rw-r--r--sys/compat/ia32/ia32_sysvec.c63
-rw-r--r--sys/compat/linux/linux_misc.c33
-rw-r--r--sys/compat/svr4/imgact_svr4.c8
-rw-r--r--sys/compat/svr4/svr4_filio.c11
-rw-r--r--sys/compat/svr4/svr4_misc.c63
-rw-r--r--sys/compat/svr4/svr4_resource.c52
6 files changed, 111 insertions, 119 deletions
diff --git a/sys/compat/ia32/ia32_sysvec.c b/sys/compat/ia32/ia32_sysvec.c
index 0b2d777..2210cec 100644
--- a/sys/compat/ia32/ia32_sysvec.c
+++ b/sys/compat/ia32/ia32_sysvec.c
@@ -273,50 +273,33 @@ static void
ia32_fixlimits(struct image_params *imgp)
{
struct proc *p = imgp->proc;
-
+ struct plimit *oldlim, *newlim;
+
+ if (ia32_maxdsiz == 0 && ia32_maxssiz == 0 && ia32_maxvmem == 0)
+ return;
+ newlim = lim_alloc();
+ PROC_LOCK(p);
+ oldlim = p->p_limit;
+ lim_copy(newlim, oldlim);
if (ia32_maxdsiz != 0) {
- if (p->p_rlimit[RLIMIT_DATA].rlim_cur > ia32_maxdsiz ||
- p->p_rlimit[RLIMIT_DATA].rlim_max > ia32_maxdsiz) {
- if (p->p_limit->p_refcnt > 1) {
- p->p_limit->p_refcnt--;
- p->p_limit = limcopy(p->p_limit);
- }
- if (p->p_rlimit[RLIMIT_DATA].rlim_cur > ia32_maxdsiz)
- p->p_rlimit[RLIMIT_DATA].rlim_cur =
- ia32_maxdsiz;
- if (p->p_rlimit[RLIMIT_DATA].rlim_max > ia32_maxdsiz)
- p->p_rlimit[RLIMIT_DATA].rlim_max =
- ia32_maxdsiz;
- }
+ if (newlim->pl_rlimit[RLIMIT_DATA].rlim_cur > ia32_maxdsiz)
+ newlim->pl_rlimit[RLIMIT_DATA].rlim_cur = ia32_maxdsiz;
+ if (newlim->pl_rlimit[RLIMIT_DATA].rlim_max > ia32_maxdsiz)
+ newlim->pl_rlimit[RLIMIT_DATA].rlim_max = ia32_maxdsiz;
}
if (ia32_maxssiz != 0) {
- if (p->p_rlimit[RLIMIT_STACK].rlim_cur > ia32_maxssiz ||
- p->p_rlimit[RLIMIT_STACK].rlim_max > ia32_maxssiz) {
- if (p->p_limit->p_refcnt > 1) {
- p->p_limit->p_refcnt--;
- p->p_limit = limcopy(p->p_limit);
- }
- if (p->p_rlimit[RLIMIT_STACK].rlim_cur > ia32_maxssiz)
- p->p_rlimit[RLIMIT_STACK].rlim_cur =
- ia32_maxssiz;
- if (p->p_rlimit[RLIMIT_STACK].rlim_max > ia32_maxssiz)
- p->p_rlimit[RLIMIT_STACK].rlim_max =
- ia32_maxssiz;
- }
+ if (newlim->pl_rlimit[RLIMIT_STACK].rlim_cur > ia32_maxssiz)
+ newlim->pl_rlimit[RLIMIT_STACK].rlim_cur = ia32_maxssiz;
+ if (newlim->pl_rlimit[RLIMIT_STACK].rlim_max > ia32_maxssiz)
+ newlim->pl_rlimit[RLIMIT_STACK].rlim_max = ia32_maxssiz;
}
if (ia32_maxvmem != 0) {
- if (p->p_rlimit[RLIMIT_VMEM].rlim_cur > ia32_maxvmem ||
- p->p_rlimit[RLIMIT_VMEM].rlim_max > ia32_maxvmem) {
- if (p->p_limit->p_refcnt > 1) {
- p->p_limit->p_refcnt--;
- p->p_limit = limcopy(p->p_limit);
- }
- if (p->p_rlimit[RLIMIT_VMEM].rlim_cur > ia32_maxvmem)
- p->p_rlimit[RLIMIT_VMEM].rlim_cur =
- ia32_maxvmem;
- if (p->p_rlimit[RLIMIT_VMEM].rlim_max > ia32_maxvmem)
- p->p_rlimit[RLIMIT_VMEM].rlim_max =
- ia32_maxvmem;
- }
+ if (newlim->pl_rlimit[RLIMIT_VMEM].rlim_cur > ia32_maxvmem)
+ newlim->pl_rlimit[RLIMIT_VMEM].rlim_cur = ia32_maxvmem;
+ if (newlim->pl_rlimit[RLIMIT_VMEM].rlim_max > ia32_maxvmem)
+ newlim->pl_rlimit[RLIMIT_VMEM].rlim_max = ia32_maxvmem;
}
+ p->p_limit = newlim;
+ PROC_UNLOCK(p);
+ lim_free(oldlim);
}
diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c
index 9938785..9e38f91 100644
--- a/sys/compat/linux/linux_misc.c
+++ b/sys/compat/linux/linux_misc.c
@@ -378,20 +378,19 @@ linux_uselib(struct thread *td, struct linux_uselib_args *args)
goto cleanup;
}
- /* To protect td->td_proc->p_rlimit in the if condition. */
- mtx_assert(&Giant, MA_OWNED);
-
/*
* text/data/bss must not exceed limits
* XXX - this is not complete. it should check current usage PLUS
* the resources needed by this library.
*/
+ PROC_LOCK(td->td_proc);
if (a_out->a_text > maxtsiz ||
- a_out->a_data + bss_size >
- td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) {
+ a_out->a_data + bss_size > lim_cur(td->td_proc, RLIMIT_DATA)) {
+ PROC_UNLOCK(td->td_proc);
error = ENOMEM;
goto cleanup;
}
+ PROC_UNLOCK(td->td_proc);
mp_fixme("Unlocked vflags access.");
/* prevent more writers */
@@ -1111,7 +1110,7 @@ linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args)
bsd_rlim.rlim_cur = (rlim_t)rlim.rlim_cur;
bsd_rlim.rlim_max = (rlim_t)rlim.rlim_max;
- return (dosetrlimit(td, which, &bsd_rlim));
+ return (kern_setrlimit(td, which, &bsd_rlim));
}
int
@@ -1119,7 +1118,7 @@ linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
{
struct l_rlimit rlim;
struct proc *p = td->td_proc;
- struct rlimit *bsd_rlp;
+ struct rlimit bsd_rlim;
u_int which;
#ifdef DEBUG
@@ -1134,12 +1133,15 @@ linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
which = linux_to_bsd_resource[args->resource];
if (which == -1)
return (EINVAL);
- bsd_rlp = &p->p_rlimit[which];
- rlim.rlim_cur = (unsigned long)bsd_rlp->rlim_cur;
+ PROC_LOCK(p);
+ lim_rlimit(p, which, &bsd_rlim);
+ PROC_UNLOCK(p);
+
+ rlim.rlim_cur = (unsigned long)bsd_rlim.rlim_cur;
if (rlim.rlim_cur == ULONG_MAX)
rlim.rlim_cur = LONG_MAX;
- rlim.rlim_max = (unsigned long)bsd_rlp->rlim_max;
+ rlim.rlim_max = (unsigned long)bsd_rlim.rlim_max;
if (rlim.rlim_max == ULONG_MAX)
rlim.rlim_max = LONG_MAX;
return (copyout(&rlim, args->rlim, sizeof(rlim)));
@@ -1150,7 +1152,7 @@ linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
{
struct l_rlimit rlim;
struct proc *p = td->td_proc;
- struct rlimit *bsd_rlp;
+ struct rlimit bsd_rlim;
u_int which;
#ifdef DEBUG
@@ -1165,10 +1167,13 @@ linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
which = linux_to_bsd_resource[args->resource];
if (which == -1)
return (EINVAL);
- bsd_rlp = &p->p_rlimit[which];
- rlim.rlim_cur = (l_ulong)bsd_rlp->rlim_cur;
- rlim.rlim_max = (l_ulong)bsd_rlp->rlim_max;
+ PROC_LOCK(p);
+ lim_rlimit(p, which, &bsd_rlim);
+ PROC_UNLOCK(p);
+
+ rlim.rlim_cur = (l_ulong)bsd_rlim.rlim_cur;
+ rlim.rlim_max = (l_ulong)bsd_rlim.rlim_max;
return (copyout(&rlim, args->rlim, sizeof(rlim)));
}
#endif /*!__alpha__*/
diff --git a/sys/compat/svr4/imgact_svr4.c b/sys/compat/svr4/imgact_svr4.c
index 5d8d550..4dc5b8f 100644
--- a/sys/compat/svr4/imgact_svr4.c
+++ b/sys/compat/svr4/imgact_svr4.c
@@ -104,14 +104,16 @@ exec_svr4_imgact(imgp)
/* text + data can't exceed file size */
if (a_out->a_data + a_out->a_text > imgp->attr->va_size)
return (EFAULT);
- /* For p_rlimit below. */
- mtx_assert(&Giant, MA_OWNED);
/*
* text/data/bss must not exceed limits
*/
+ PROC_LOCK(imgp->proc);
if (a_out->a_text > maxtsiz ||
- a_out->a_data + bss_size > imgp->proc->p_rlimit[RLIMIT_DATA].rlim_cur)
+ a_out->a_data + bss_size > lim_cur(imgp->proc, RLIMIT_DATA)) {
+ PROC_UNLOCK(imgp->proc);
return (ENOMEM);
+ }
+ PROC_UNLOCK(imgp->proc);
VOP_UNLOCK(imgp->vp, 0, td);
diff --git a/sys/compat/svr4/svr4_filio.c b/sys/compat/svr4/svr4_filio.c
index 79b9bf4..c15c5b4 100644
--- a/sys/compat/svr4/svr4_filio.c
+++ b/sys/compat/svr4/svr4_filio.c
@@ -66,10 +66,13 @@ svr4_sys_poll(td, uap)
int idx = 0, cerr;
u_long siz;
- mtx_assert(&Giant, MA_OWNED);
- if (uap->nfds > td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur &&
- uap->nfds > FD_SETSIZE)
- return (EINVAL);
+ PROC_LOCK(td->td_proc);
+ if (uap->nfds > lim_cur(td->td_proc, RLIMIT_NOFILE) &&
+ uap->nfds > FD_SETSIZE) {
+ PROC_UNLOCK(td->td_proc);
+ return (EINVAL);
+ }
+ PROC_UNLOCK(td->td_proc);
pa.fds = uap->fds;
pa.nfds = uap->nfds;
diff --git a/sys/compat/svr4/svr4_misc.c b/sys/compat/svr4/svr4_misc.c
index f29ee8b..c568a5d 100644
--- a/sys/compat/svr4/svr4_misc.c
+++ b/sys/compat/svr4/svr4_misc.c
@@ -820,15 +820,15 @@ svr4_sys_break(td, uap)
base = round_page((vm_offset_t) vm->vm_daddr);
ns = (vm_offset_t)uap->nsize;
new = round_page(ns);
- /* For p_rlimit. */
- mtx_assert(&Giant, MA_OWNED);
if (new > base) {
- if ((new - base) > (unsigned) td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) {
+ PROC_LOCK(p);
+ if ((new - base) > (unsigned)lim_cur(p, RLIMIT_DATA)) {
+ PROC_UNLOCK(p);
return ENOMEM;
- }
- if (new >= VM_MAXUSER_ADDRESS) {
- return (ENOMEM);
- }
+ }
+ PROC_UNLOCK(p);
+ if (new >= VM_MAXUSER_ADDRESS)
+ return (ENOMEM);
} else if (new < base) {
/*
* This is simply an invalid value. If someone wants to
@@ -843,8 +843,12 @@ svr4_sys_break(td, uap)
if (new > old) {
vm_size_t diff;
diff = new - old;
- if (vm->vm_map.size + diff > p->p_rlimit[RLIMIT_VMEM].rlim_cur)
+ PROC_LOCK(p);
+ if (vm->vm_map.size + diff > lim_cur(p, RLIMIT_VMEM)) {
+ PROC_UNLOCK(p);
return(ENOMEM);
+ }
+ PROC_UNLOCK(p);
rv = vm_map_find(&vm->vm_map, NULL, 0, &old, diff, FALSE,
VM_PROT_ALL, VM_PROT_ALL, 0);
if (rv != KERN_SUCCESS) {
@@ -922,42 +926,33 @@ svr4_sys_ulimit(td, uap)
struct svr4_sys_ulimit_args *uap;
{
int *retval = td->td_retval;
+ int error;
switch (uap->cmd) {
case SVR4_GFILLIM:
- /* For p_rlimit below. */
- mtx_assert(&Giant, MA_OWNED);
- *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur / 512;
+ PROC_LOCK(td->td_proc);
+ *retval = lim_cur(td->td_proc, RLIMIT_FSIZE) / 512;
+ PROC_UNLOCK(td->td_proc);
if (*retval == -1)
*retval = 0x7fffffff;
return 0;
case SVR4_SFILLIM:
{
- int error;
- struct __setrlimit_args srl;
struct rlimit krl;
- caddr_t sg = stackgap_init();
- struct rlimit *url = (struct rlimit *)
- stackgap_alloc(&sg, sizeof *url);
krl.rlim_cur = uap->newlimit * 512;
- mtx_assert(&Giant, MA_OWNED);
- krl.rlim_max = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_max;
-
- error = copyout(&krl, url, sizeof(*url));
- if (error)
- return error;
-
- srl.which = RLIMIT_FSIZE;
- srl.rlp = url;
+ PROC_LOCK(td->td_proc);
+ krl.rlim_max = lim_max(td->td_proc, RLIMIT_FSIZE);
+ PROC_UNLOCK(td->td_proc);
- error = setrlimit(td, &srl);
+ error = kern_setrlimit(td, RLIMIT_FSIZE, &krl);
if (error)
return error;
- mtx_assert(&Giant, MA_OWNED);
- *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+ PROC_LOCK(td->td_proc);
+ *retval = lim_cur(td->td_proc, RLIMIT_FSIZE);
+ PROC_UNLOCK(td->td_proc);
if (*retval == -1)
*retval = 0x7fffffff;
return 0;
@@ -968,12 +963,15 @@ svr4_sys_ulimit(td, uap)
struct vmspace *vm = td->td_proc->p_vmspace;
register_t r;
- mtx_assert(&Giant, MA_OWNED);
- r = td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur;
+ PROC_LOCK(td->td_proc);
+ r = lim_cur(td->td_proc, RLIMIT_DATA);
+ PROC_UNLOCK(td->td_proc);
if (r == -1)
r = 0x7fffffff;
+ mtx_lock(&Giant); /* XXX */
r += (long) vm->vm_daddr;
+ mtx_unlock(&Giant);
if (r < 0)
r = 0x7fffffff;
*retval = r;
@@ -981,8 +979,9 @@ svr4_sys_ulimit(td, uap)
}
case SVR4_GDESLIM:
- mtx_assert(&Giant, MA_OWNED);
- *retval = td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur;
+ PROC_LOCK(td->td_proc);
+ *retval = lim_cur(td->td_proc, RLIMIT_NOFILE);
+ PROC_UNLOCK(td->td_proc);
if (*retval == -1)
*retval = 0x7fffffff;
return 0;
diff --git a/sys/compat/svr4/svr4_resource.c b/sys/compat/svr4/svr4_resource.c
index f04d591..6aed48d 100644
--- a/sys/compat/svr4/svr4_resource.c
+++ b/sys/compat/svr4/svr4_resource.c
@@ -136,9 +136,9 @@ svr4_sys_getrlimit(td, uap)
if (rl == -1)
return EINVAL;
- /* For p_rlimit. */
- mtx_assert(&Giant, MA_OWNED);
- blim = td->td_proc->p_rlimit[rl];
+ PROC_LOCK(td->td_proc);
+ lim_rlimit(td->td_proc, rl, &blim);
+ PROC_UNLOCK(td->td_proc);
/*
* Our infinity, is their maxfiles.
@@ -177,20 +177,20 @@ svr4_sys_setrlimit(td, uap)
struct svr4_sys_setrlimit_args *uap;
{
int rl = svr4_to_native_rl(uap->which);
- struct rlimit blim, *limp;
+ struct rlimit blim, curlim;
struct svr4_rlimit slim;
int error;
if (rl == -1)
return EINVAL;
- /* For p_rlimit. */
- mtx_assert(&Giant, MA_OWNED);
- limp = &td->td_proc->p_rlimit[rl];
-
if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
return error;
+ PROC_LOCK(td->td_proc);
+ lim_rlimit(td->td_proc, rl, &curlim);
+ PROC_UNLOCK(td->td_proc);
+
/*
* if the limit is SVR4_RLIM_INFINITY, then we set it to our
* unlimited.
@@ -205,20 +205,20 @@ svr4_sys_setrlimit(td, uap)
else if (OKLIMIT(slim.rlim_max))
blim.rlim_max = (rlim_t) slim.rlim_max;
else if (slim.rlim_max == SVR4_RLIM_SAVED_MAX)
- blim.rlim_max = limp->rlim_max;
+ blim.rlim_max = curlim.rlim_max;
else if (slim.rlim_max == SVR4_RLIM_SAVED_CUR)
- blim.rlim_max = limp->rlim_cur;
+ blim.rlim_max = curlim.rlim_cur;
if (slim.rlim_cur == SVR4_RLIM_INFINITY)
blim.rlim_cur = RLIM_INFINITY;
else if (OKLIMIT(slim.rlim_cur))
blim.rlim_cur = (rlim_t) slim.rlim_cur;
else if (slim.rlim_cur == SVR4_RLIM_SAVED_MAX)
- blim.rlim_cur = limp->rlim_max;
+ blim.rlim_cur = curlim.rlim_max;
else if (slim.rlim_cur == SVR4_RLIM_SAVED_CUR)
- blim.rlim_cur = limp->rlim_cur;
+ blim.rlim_cur = curlim.rlim_cur;
- return dosetrlimit(td, rl, &blim);
+ return (kern_setrlimit(td, rl, &blim));
}
@@ -234,9 +234,9 @@ svr4_sys_getrlimit64(td, uap)
if (rl == -1)
return EINVAL;
- /* For p_rlimit. */
- mtx_assert(&Giant, MA_OWNED);
- blim = td->td_proc->p_rlimit[rl];
+ PROC_LOCK(td->td_proc);
+ lim_rlimit(td->td_proc, rl, &blim);
+ PROC_UNLOCK(td->td_proc);
/*
* Our infinity, is their maxfiles.
@@ -275,20 +275,20 @@ svr4_sys_setrlimit64(td, uap)
struct svr4_sys_setrlimit64_args *uap;
{
int rl = svr4_to_native_rl(uap->which);
- struct rlimit blim, *limp;
+ struct rlimit blim, curlim;
struct svr4_rlimit64 slim;
int error;
if (rl == -1)
return EINVAL;
- /* For p_rlimit. */
- mtx_assert(&Giant, MA_OWNED);
- limp = &td->td_proc->p_rlimit[rl];
-
if ((error = copyin(uap->rlp, &slim, sizeof(slim))) != 0)
return error;
+ PROC_LOCK(td->td_proc);
+ lim_rlimit(td->td_proc, rl, &curlim);
+ PROC_UNLOCK(td->td_proc);
+
/*
* if the limit is SVR4_RLIM64_INFINITY, then we set it to our
* unlimited.
@@ -303,18 +303,18 @@ svr4_sys_setrlimit64(td, uap)
else if (OKLIMIT64(slim.rlim_max))
blim.rlim_max = (rlim_t) slim.rlim_max;
else if (slim.rlim_max == SVR4_RLIM64_SAVED_MAX)
- blim.rlim_max = limp->rlim_max;
+ blim.rlim_max = curlim.rlim_max;
else if (slim.rlim_max == SVR4_RLIM64_SAVED_CUR)
- blim.rlim_max = limp->rlim_cur;
+ blim.rlim_max = curlim.rlim_cur;
if (slim.rlim_cur == SVR4_RLIM64_INFINITY)
blim.rlim_cur = RLIM_INFINITY;
else if (OKLIMIT64(slim.rlim_cur))
blim.rlim_cur = (rlim_t) slim.rlim_cur;
else if (slim.rlim_cur == SVR4_RLIM64_SAVED_MAX)
- blim.rlim_cur = limp->rlim_max;
+ blim.rlim_cur = curlim.rlim_max;
else if (slim.rlim_cur == SVR4_RLIM64_SAVED_CUR)
- blim.rlim_cur = limp->rlim_cur;
+ blim.rlim_cur = curlim.rlim_cur;
- return dosetrlimit(td, rl, &blim);
+ return (kern_setrlimit(td, rl, &blim));
}
OpenPOWER on IntegriCloud