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

/*	kern_resource.c	6.2	84/05/22	*/

#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 = allproc; p != NULL; p = p->p_nxt) {
			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 = allproc; p != NULL; p = p->p_nxt) {
			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 = allproc; p != NULL; p = p->p_nxt)
			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 = allproc; p != NULL; p = p->p_nxt)
			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
1d348849	1	/* kern_resource.c 6.2 84/05/22 */
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;
1d348849	45	for (p = allproc; p != NULL; p = p->p_nxt) {
db1874da BJ	46	if (p->p_pgrp == uap->who &&
	47	p->p_nice < u.u_r.r_val1) {
	48	u.u_r.r_val1 = p->p_nice;
	49	u.u_error = 0;
	50	}
93cc02ac BJ	51	}
	52	break;
	53
	54	case PRIO_USER:
	55	if (uap->who == 0)
	56	uap->who = u.u_uid;
1d348849	57	for (p = allproc; p != NULL; p = p->p_nxt) {
93cc02ac BJ	58	if (p->p_uid == uap->who &&
	59	p->p_nice < u.u_r.r_val1) {
	60	u.u_r.r_val1 = p->p_nice;
	61	u.u_error = 0;
	62	}
	63	}
db1874da BJ	64	break;
	65
	66	default:
	67	u.u_error = EINVAL;
	68	break;
	69	}
	70	u.u_r.r_val1 -= NZERO;
	71	}
	72
	73	setpriority()
	74	{
	75	register struct a {
	76	int which;
	77	int who;
	78	int prio;
	79	} uap = (struct a )u.u_ap;
	80	register struct proc *p;
	81
	82	u.u_error = ESRCH;
	83	switch (uap->which) {
	84
	85	case PRIO_PROCESS:
93cc02ac BJ	86	if (uap->who == 0)
	87	p = u.u_procp;
	88	else
	89	p = pfind(uap->who);
db1874da BJ	90	if (p == 0)
	91	return;
	92	donice(p, uap->prio);
	93	break;
	94
	95	case PRIO_PGRP:
93cc02ac BJ	96	if (uap->who == 0)
93cc02ac BJ	97	uap->who = u.u_procp->p_pgrp;
1d348849	98	for (p = allproc; p != NULL; p = p->p_nxt)
db1874da BJ	99	if (p->p_pgrp == uap->who)
	100	donice(p, uap->prio);
	101	break;
	102
93cc02ac BJ	103	case PRIO_USER:
	104	if (uap->who == 0)
	105	uap->who = u.u_uid;
1d348849	106	for (p = allproc; p != NULL; p = p->p_nxt)
93cc02ac BJ	107	if (p->p_uid == uap->who)
	108	donice(p, uap->prio);
	109	break;
	110
db1874da BJ	111	default:
	112	u.u_error = EINVAL;
	113	break;
	114	}
	115	}
	116
	117	donice(p, n)
	118	register struct proc *p;
	119	register int n;
	120	{
	121
	122	if (u.u_uid && u.u_ruid &&
	123	u.u_uid != p->p_uid && u.u_ruid != p->p_uid) {
93cc02ac	124	u.u_error = EACCES;
db1874da BJ	125	return;
db1874da BJ	126	}
93cc02ac	127	n += NZERO;
db1874da BJ	128	if (n >= 2*NZERO)
	129	n = 2*NZERO - 1;
	130	if (n < 0)
	131	n = 0;
93cc02ac BJ	132	if (n < p->p_nice && !suser()) {
93cc02ac BJ	133	u.u_error = EACCES;
db1874da	134	return;
93cc02ac	135	}
db1874da BJ	136	p->p_nice = n;
	137	(void) setpri(p);
	138	if (u.u_error == ESRCH)
	139	u.u_error = 0;
	140	}
	141
1edb1cf8	142	setrlimit()
db1874da BJ	143	{
	144	register struct a {
	145	u_int which;
	146	struct rlimit *lim;
	147	} uap = (struct a )u.u_ap;
	148	struct rlimit alim;
	149	register struct rlimit *alimp;
	150
	151	if (uap->which >= RLIM_NLIMITS) {
	152	u.u_error = EINVAL;
	153	return;
	154	}
	155	alimp = &u.u_rlimit[uap->which];
127f7d76 SL	156	u.u_error = copyin((caddr_t)uap->lim, (caddr_t)&alim,
	157	sizeof (struct rlimit));
	158	if (u.u_error)
db1874da	159	return;
db1874da BJ	160	if (alim.rlim_cur > alimp->rlim_max \|\| alim.rlim_max > alimp->rlim_max)
	161	if (!suser())
	162	return;
	163	switch (uap->which) {
	164
	165	case RLIMIT_DATA:
	166	if (alim.rlim_cur > ctob(MAXDSIZ))
	167	alim.rlim_cur = ctob(MAXDSIZ);
	168	break;
	169
	170	case RLIMIT_STACK:
	171	if (alim.rlim_cur > ctob(MAXSSIZ))
	172	alim.rlim_cur = ctob(MAXSSIZ);
	173	break;
	174	}
	175	*alimp = alim;
	176	if (uap->which == RLIMIT_RSS)
	177	u.u_procp->p_maxrss = alim.rlim_cur/NBPG;
	178	}
	179
1edb1cf8	180	getrlimit()
db1874da BJ	181	{
	182	register struct a {
	183	u_int which;
	184	struct rlimit *rlp;
	185	} uap = (struct a )u.u_ap;
	186
	187	if (uap->which >= RLIM_NLIMITS) {
	188	u.u_error = EINVAL;
	189	return;
	190	}
127f7d76 SL	191	u.u_error = copyout((caddr_t)&u.u_rlimit[uap->which], (caddr_t)uap->rlp,
127f7d76 SL	192	sizeof (struct rlimit));
db1874da BJ	193	}
	194
	195	getrusage()
	196	{
	197	register struct a {
	198	int who;
	199	struct rusage *rusage;
	200	} uap = (struct a )u.u_ap;
	201	register struct rusage *rup;
	202
	203	switch (uap->who) {
	204
	205	case RUSAGE_SELF:
	206	rup = &u.u_ru;
	207	break;
	208
	209	case RUSAGE_CHILDREN:
	210	rup = &u.u_cru;
	211	break;
	212
	213	default:
	214	u.u_error = EINVAL;
	215	return;
	216	}
127f7d76 SL	217	u.u_error = copyout((caddr_t)rup, (caddr_t)uap->rusage,
127f7d76 SL	218	sizeof (struct rusage));
db1874da BJ	219	}
	220
	221	ruadd(ru, ru2)
	222	register struct rusage ru, ru2;
	223	{
3fd23f5c	224	register long ip, ip2;
db1874da BJ	225	register int i;
	226
	227	timevaladd(&ru->ru_utime, &ru2->ru_utime);
	228	timevaladd(&ru->ru_stime, &ru2->ru_stime);
	229	if (ru->ru_maxrss < ru2->ru_maxrss)
	230	ru->ru_maxrss = ru2->ru_maxrss;
	231	ip = &ru->ru_first; ip2 = &ru2->ru_first;
	232	for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
	233	ip++ += ip2++;
	234	}