[unix-history] / usr / src / sys / kern / kern_resource.c

/*	kern_resource.c	4.22	83/05/27	*/

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/inode.h"
#include "../h/proc.h"
#include "../h/seg.h"
#include "../h/fs.h"
#include "../h/uio.h"
#include "../h/vm.h"
#include "../h/kernel.h"

/*
 * Resource controls and accounting.
 */

getpriority()
{
	register struct a {
		int	which;
		int	who;
	} *uap = (struct a *)u.u_ap;
	register struct proc *p;

	u.u_r.r_val1 = NZERO+20;
	u.u_error = ESRCH;
	switch (uap->which) {

	case PRIO_PROCESS:
		if (uap->who == 0)
			p = u.u_procp;
		else
			p = pfind(uap->who);
		if (p == 0)
			return;
		u.u_r.r_val1 = p->p_nice;
		u.u_error = 0;
		break;

	case PRIO_PGRP:
		if (uap->who == 0)
			uap->who = u.u_procp->p_pgrp;
		for (p = proc; p < procNPROC; p++) {
			if (p->p_stat == NULL)
				continue;
			if (p->p_pgrp == uap->who &&
			    p->p_nice < u.u_r.r_val1) {
				u.u_r.r_val1 = p->p_nice;
				u.u_error = 0;
			}
		}
		break;

	case PRIO_USER:
		if (uap->who == 0)
			uap->who = u.u_uid;
		for (p = proc; p < procNPROC; p++) {
			if (p->p_stat == NULL)
				continue;
			if (p->p_uid == uap->who &&
			    p->p_nice < u.u_r.r_val1) {
				u.u_r.r_val1 = p->p_nice;
				u.u_error = 0;
			}
		}
		break;

	default:
		u.u_error = EINVAL;
		break;
	}
	u.u_r.r_val1 -= NZERO;
}

setpriority()
{
	register struct a {
		int	which;
		int	who;
		int	prio;
	} *uap = (struct a *)u.u_ap;
	register struct proc *p;

	u.u_error = ESRCH;
	switch (uap->which) {

	case PRIO_PROCESS:
		if (uap->who == 0)
			p = u.u_procp;
		else
			p = pfind(uap->who);
		if (p == 0)
			return;
		donice(p, uap->prio);
		break;

	case PRIO_PGRP:
		if (uap->who == 0)
			uap->who = u.u_procp->p_pgrp;
		for (p = proc; p < procNPROC; p++)
			if (p->p_pgrp == uap->who)
				donice(p, uap->prio);
		break;

	case PRIO_USER:
		if (uap->who == 0)
			uap->who = u.u_uid;
		for (p = proc; p < procNPROC; p++)
			if (p->p_uid == uap->who)
				donice(p, uap->prio);
		break;

	default:
		u.u_error = EINVAL;
		break;
	}
}

donice(p, n)
	register struct proc *p;
	register int n;
{

	if (u.u_uid && u.u_ruid &&
	    u.u_uid != p->p_uid && u.u_ruid != p->p_uid) {
		u.u_error = EACCES;
		return;
	}
	n += NZERO;
	if (n >= 2*NZERO)
		n = 2*NZERO - 1;
	if (n < 0)
		n = 0;
	if (n < p->p_nice && !suser()) {
		u.u_error = EACCES;
		return;
	}
	p->p_nice = n;
	(void) setpri(p);
	if (u.u_error == ESRCH)
		u.u_error = 0;
}

setrlimit()
{
	register struct a {
		u_int	which;
		struct	rlimit *lim;
	} *uap = (struct a *)u.u_ap;
	struct rlimit alim;
	register struct rlimit *alimp;

	if (uap->which >= RLIM_NLIMITS) {
		u.u_error = EINVAL;
		return;
	}
	alimp = &u.u_rlimit[uap->which];
	u.u_error = copyin((caddr_t)uap->lim, (caddr_t)&alim,
		sizeof (struct rlimit));
	if (u.u_error)
		return;
	if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)
		if (!suser())
			return;
	switch (uap->which) {

	case RLIMIT_DATA:
		if (alim.rlim_cur > ctob(MAXDSIZ))
			alim.rlim_cur = ctob(MAXDSIZ);
		break;

	case RLIMIT_STACK:
		if (alim.rlim_cur > ctob(MAXSSIZ))
			alim.rlim_cur = ctob(MAXSSIZ);
		break;
	}
	*alimp = alim;
	if (uap->which == RLIMIT_RSS)
		u.u_procp->p_maxrss = alim.rlim_cur/NBPG;
}

getrlimit()
{
	register struct a {
		u_int	which;
		struct	rlimit *rlp;
	} *uap = (struct a *)u.u_ap;

	if (uap->which >= RLIM_NLIMITS) {
		u.u_error = EINVAL;
		return;
	}
	u.u_error = copyout((caddr_t)&u.u_rlimit[uap->which], (caddr_t)uap->rlp,
	    sizeof (struct rlimit));
}

getrusage()
{
	register struct a {
		int	who;
		struct	rusage *rusage;
	} *uap = (struct a *)u.u_ap;
	register struct rusage *rup;

	switch (uap->who) {

	case RUSAGE_SELF:
		rup = &u.u_ru;
		break;

	case RUSAGE_CHILDREN:
		rup = &u.u_cru;
		break;

	default:
		u.u_error = EINVAL;
		return;
	}
	u.u_error = copyout((caddr_t)rup, (caddr_t)uap->rusage,
	    sizeof (struct rusage));
}

ruadd(ru, ru2)
	register struct rusage *ru, *ru2;
{
	register long *ip, *ip2;
	register int i;

	timevaladd(&ru->ru_utime, &ru2->ru_utime);
	timevaladd(&ru->ru_stime, &ru2->ru_stime);
	if (ru->ru_maxrss < ru2->ru_maxrss)
		ru->ru_maxrss = ru2->ru_maxrss;
	ip = &ru->ru_first; ip2 = &ru2->ru_first;
	for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
		*ip++ += *ip2++;
}
Commit	Line	Data
88a7a62a	1	/* kern_resource.c 4.22 83/05/27 */
1b64633a BJ	2
	3	#include "../h/param.h"
	4	#include "../h/systm.h"
1b64633a BJ	5	#include "../h/dir.h"
	6	#include "../h/user.h"
	7	#include "../h/inode.h"
	8	#include "../h/proc.h"
	9	#include "../h/seg.h"
4147b3f6	10	#include "../h/fs.h"
9a837405	11	#include "../h/uio.h"
db1874da	12	#include "../h/vm.h"
04ac1ad8	13	#include "../h/kernel.h"
db1874da	14
93cc02ac BJ	15	/*
	16	* Resource controls and accounting.
	17	*/
	18
db1874da BJ	19	getpriority()
	20	{
	21	register struct a {
	22	int which;
	23	int who;
	24	} uap = (struct a )u.u_ap;
	25	register struct proc *p;
	26
	27	u.u_r.r_val1 = NZERO+20;
	28	u.u_error = ESRCH;
	29	switch (uap->which) {
	30
	31	case PRIO_PROCESS:
	32	if (uap->who == 0)
	33	p = u.u_procp;
	34	else
	35	p = pfind(uap->who);
	36	if (p == 0)
	37	return;
19c68d6d	38	u.u_r.r_val1 = p->p_nice;
93cc02ac	39	u.u_error = 0;
db1874da BJ	40	break;
	41
	42	case PRIO_PGRP:
	43	if (uap->who == 0)
	44	uap->who = u.u_procp->p_pgrp;
93cc02ac BJ	45	for (p = proc; p < procNPROC; p++) {
	46	if (p->p_stat == NULL)
	47	continue;
db1874da BJ	48	if (p->p_pgrp == uap->who &&
	49	p->p_nice < u.u_r.r_val1) {
	50	u.u_r.r_val1 = p->p_nice;
	51	u.u_error = 0;
	52	}
93cc02ac BJ	53	}
	54	break;
	55
	56	case PRIO_USER:
	57	if (uap->who == 0)
	58	uap->who = u.u_uid;
	59	for (p = proc; p < procNPROC; p++) {
	60	if (p->p_stat == NULL)
	61	continue;
	62	if (p->p_uid == uap->who &&
	63	p->p_nice < u.u_r.r_val1) {
	64	u.u_r.r_val1 = p->p_nice;
	65	u.u_error = 0;
	66	}
	67	}
db1874da BJ	68	break;
	69
	70	default:
	71	u.u_error = EINVAL;
	72	break;
	73	}
	74	u.u_r.r_val1 -= NZERO;
	75	}
	76
	77	setpriority()
	78	{
	79	register struct a {
	80	int which;
	81	int who;
	82	int prio;
	83	} uap = (struct a )u.u_ap;
	84	register struct proc *p;
	85
	86	u.u_error = ESRCH;
	87	switch (uap->which) {
	88
	89	case PRIO_PROCESS:
93cc02ac BJ	90	if (uap->who == 0)
	91	p = u.u_procp;
	92	else
	93	p = pfind(uap->who);
db1874da BJ	94	if (p == 0)
	95	return;
	96	donice(p, uap->prio);
	97	break;
	98
	99	case PRIO_PGRP:
93cc02ac BJ	100	if (uap->who == 0)
93cc02ac BJ	101	uap->who = u.u_procp->p_pgrp;
db1874da BJ	102	for (p = proc; p < procNPROC; p++)
	103	if (p->p_pgrp == uap->who)
	104	donice(p, uap->prio);
	105	break;
	106
93cc02ac BJ	107	case PRIO_USER:
	108	if (uap->who == 0)
	109	uap->who = u.u_uid;
	110	for (p = proc; p < procNPROC; p++)
	111	if (p->p_uid == uap->who)
	112	donice(p, uap->prio);
	113	break;
	114
db1874da BJ	115	default:
	116	u.u_error = EINVAL;
	117	break;
	118	}
	119	}
	120
	121	donice(p, n)
	122	register struct proc *p;
	123	register int n;
	124	{
	125
	126	if (u.u_uid && u.u_ruid &&
	127	u.u_uid != p->p_uid && u.u_ruid != p->p_uid) {
93cc02ac	128	u.u_error = EACCES;
db1874da BJ	129	return;
db1874da BJ	130	}
93cc02ac	131	n += NZERO;
db1874da BJ	132	if (n >= 2*NZERO)
	133	n = 2*NZERO - 1;
	134	if (n < 0)
	135	n = 0;
93cc02ac BJ	136	if (n < p->p_nice && !suser()) {
93cc02ac BJ	137	u.u_error = EACCES;
db1874da	138	return;
93cc02ac	139	}
db1874da BJ	140	p->p_nice = n;
	141	(void) setpri(p);
	142	if (u.u_error == ESRCH)
	143	u.u_error = 0;
	144	}
	145
1edb1cf8	146	setrlimit()
db1874da BJ	147	{
	148	register struct a {
	149	u_int which;
	150	struct rlimit *lim;
	151	} uap = (struct a )u.u_ap;
	152	struct rlimit alim;
	153	register struct rlimit *alimp;
	154
	155	if (uap->which >= RLIM_NLIMITS) {
	156	u.u_error = EINVAL;
	157	return;
	158	}
	159	alimp = &u.u_rlimit[uap->which];
127f7d76 SL	160	u.u_error = copyin((caddr_t)uap->lim, (caddr_t)&alim,
	161	sizeof (struct rlimit));
	162	if (u.u_error)
db1874da	163	return;
db1874da BJ	164	if (alim.rlim_cur > alimp->rlim_max \|\| alim.rlim_max > alimp->rlim_max)
	165	if (!suser())
	166	return;
	167	switch (uap->which) {
	168
	169	case RLIMIT_DATA:
	170	if (alim.rlim_cur > ctob(MAXDSIZ))
	171	alim.rlim_cur = ctob(MAXDSIZ);
	172	break;
	173
	174	case RLIMIT_STACK:
	175	if (alim.rlim_cur > ctob(MAXSSIZ))
	176	alim.rlim_cur = ctob(MAXSSIZ);
	177	break;
	178	}
	179	*alimp = alim;
	180	if (uap->which == RLIMIT_RSS)
	181	u.u_procp->p_maxrss = alim.rlim_cur/NBPG;
	182	}
	183
1edb1cf8	184	getrlimit()
db1874da BJ	185	{
	186	register struct a {
	187	u_int which;
	188	struct rlimit *rlp;
	189	} uap = (struct a )u.u_ap;
	190
	191	if (uap->which >= RLIM_NLIMITS) {
	192	u.u_error = EINVAL;
	193	return;
	194	}
127f7d76 SL	195	u.u_error = copyout((caddr_t)&u.u_rlimit[uap->which], (caddr_t)uap->rlp,
127f7d76 SL	196	sizeof (struct rlimit));
db1874da BJ	197	}
	198
	199	getrusage()
	200	{
	201	register struct a {
	202	int who;
	203	struct rusage *rusage;
	204	} uap = (struct a )u.u_ap;
	205	register struct rusage *rup;
	206
	207	switch (uap->who) {
	208
	209	case RUSAGE_SELF:
	210	rup = &u.u_ru;
	211	break;
	212
	213	case RUSAGE_CHILDREN:
	214	rup = &u.u_cru;
	215	break;
	216
	217	default:
	218	u.u_error = EINVAL;
	219	return;
	220	}
127f7d76 SL	221	u.u_error = copyout((caddr_t)rup, (caddr_t)uap->rusage,
127f7d76 SL	222	sizeof (struct rusage));
db1874da BJ	223	}
	224
	225	ruadd(ru, ru2)
	226	register struct rusage ru, ru2;
	227	{
3fd23f5c	228	register long ip, ip2;
db1874da BJ	229	register int i;
	230
	231	timevaladd(&ru->ru_utime, &ru2->ru_utime);
	232	timevaladd(&ru->ru_stime, &ru2->ru_stime);
	233	if (ru->ru_maxrss < ru2->ru_maxrss)
	234	ru->ru_maxrss = ru2->ru_maxrss;
	235	ip = &ru->ru_first; ip2 = &ru2->ru_first;
	236	for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
	237	ip++ += ip2++;
	238	}