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

/*	kern_xxx.c	4.3	83/06/02	*/

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/kernel.h"
#include "../h/proc.h"
#include "../h/reboot.h"

gethostid()
{

	u.u_r.r_val1 = hostid;
}

sethostid()
{
	struct a {
		int	hostid;
	} *uap = (struct a *)u.u_ap;

	if (suser())
		hostid = uap->hostid;
}

gethostname()
{
	register struct a {
		char	*hostname;
		int	len;
	} *uap = (struct a *)u.u_ap;
	register u_int len;

	len = uap->len;
	if (len > hostnamelen + 1)
		len = hostnamelen + 1;
	u.u_error = copyout((caddr_t)hostname, (caddr_t)uap->hostname, len);
}

sethostname()
{
	register struct a {
		char	*hostname;
		u_int	len;
	} *uap = (struct a *)u.u_ap;

	if (!suser())
		return;
	if (uap->len > sizeof (hostname) - 1) {
		u.u_error = EINVAL;
		return;
	}
	hostnamelen = uap->len;
	u.u_error = copyin((caddr_t)uap->hostname, hostname, uap->len);
	hostname[hostnamelen] = 0;
}

reboot()
{
	register struct a {
		int	opt;
	};

	if (suser())
		boot(RB_BOOT, ((struct a *)u.u_ap)->opt);
}

#ifndef NOCOMPAT
#include "../h/quota.h"

osetuid()
{
	register uid;
	register struct a {
		int	uid;
	} *uap;

	uap = (struct a *)u.u_ap;
	uid = uap->uid;
	if (u.u_ruid == uid || u.u_uid == uid || suser()) {
#ifdef QUOTA
		if (u.u_quota->q_uid != uid) {
			qclean();
			qstart(getquota(uid, 0, 0));
		}
#endif
		u.u_uid = uid;
		u.u_procp->p_uid = uid;
		u.u_ruid = uid;
	}
}

osetgid()
{
	register gid;
	register struct a {
		int	gid;
	} *uap;

	uap = (struct a *)u.u_ap;
	gid = uap->gid;
	if (u.u_rgid == gid || u.u_gid == gid || suser()) {
		leavegroup(u.u_rgid);
		(void) entergroup(gid);
		u.u_gid = gid;
		u.u_rgid = gid;
	}
}

/*
 * Pid of zero implies current process.
 * Pgrp -1 is getpgrp system call returning
 * current process group.
 */
osetpgrp()
{
	register struct proc *p;
	register struct a {
		int	pid;
		int	pgrp;
	} *uap;

	uap = (struct a *)u.u_ap;
	if (uap->pid == 0)
		p = u.u_procp;
	else {
		p = pfind(uap->pid);
		if (p == 0) {
			u.u_error = ESRCH;
			return;
		}
	}
	if (uap->pgrp <= 0) {
		u.u_r.r_val1 = p->p_pgrp;
		return;
	}
	if (p->p_uid != u.u_uid && u.u_uid && !inferior(p)) {
		u.u_error = EPERM;
		return;
	}
	p->p_pgrp = uap->pgrp;
}

otime()
{

	u.u_r.r_time = time.tv_sec;
}

ostime()
{
	register struct a {
		int	time;
	} *uap = (struct a *)u.u_ap;
	struct timeval tv;

	tv.tv_sec = uap->time;
	tv.tv_usec = 0;
	setthetime(&tv);
}

/* from old timeb.h */
struct timeb {
	time_t	time;
	u_short	millitm;
	short	timezone;
	short	dstflag;
};

oftime()
{
	register struct a {
		struct	timeb	*tp;
	} *uap;
	struct timeb tb;

	uap = (struct a *)u.u_ap;
	(void) spl7();
	tb.time = time.tv_sec;
	tb.millitm = time.tv_usec / 1000;
	(void) spl0();
	tb.timezone = tz.tz_minuteswest;
	tb.dstflag = tz.tz_dsttime;
	u.u_error = copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb));
}

oalarm()
{
	register struct a {
		int	deltat;
	} *uap = (struct a *)u.u_ap;
	register struct proc *p = u.u_procp;
	int s = spl7();

	untimeout(realitexpire, (caddr_t)p);
	timerclear(&p->p_realtimer.it_interval);
	u.u_r.r_val1 = 0;
	if (timerisset(&p->p_realtimer.it_value) &&
	    timercmp(&p->p_realtimer.it_value, &time, >))
		u.u_r.r_val1 = p->p_realtimer.it_value.tv_sec - time.tv_sec;
	if (uap->deltat == 0) {
		timerclear(&p->p_realtimer.it_value);
		splx(s);
		return;
	}
	p->p_realtimer.it_value = time;
	p->p_realtimer.it_value.tv_sec += uap->deltat;
	timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
	splx(s);
}

onice()
{
	register struct a {
		int	niceness;
	} *uap = (struct a *)u.u_ap;
	register struct proc *p = u.u_procp;

	donice(p, (p->p_nice-NZERO)+uap->niceness);
}

#include "../h/times.h"

otimes()
{
	register struct a {
		struct	tms *tmsb;
	} *uap = (struct a *)u.u_ap;
	struct tms atms;

	atms.tms_utime = scale60(&u.u_ru.ru_utime);
	atms.tms_stime = scale60(&u.u_ru.ru_stime);
	atms.tms_cutime = scale60(&u.u_cru.ru_utime);
	atms.tms_cstime = scale60(&u.u_cru.ru_stime);
	u.u_error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
}

scale60(tvp)
	register struct timeval *tvp;
{

	return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
}

#include "../h/vtimes.h"

ovtimes()
{
	register struct a {
		struct	vtimes *par;
		struct	vtimes *chi;
	} *uap = (struct a *)u.u_ap;
	struct vtimes avt;

	if (uap->par) {
		getvtimes(&u.u_ru, &avt);
		u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->par,
			sizeof (avt));
		if (u.u_error)
			return;
	}
	if (uap->chi) {
		getvtimes(&u.u_cru, &avt);
		u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->chi,
			sizeof (avt));
		if (u.u_error)
			return;
	}
}

#include "../machine/psl.h"
#include "../machine/reg.h"

owait()
{
	struct rusage ru;
	struct vtimes *vtp, avt;

	if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) {
		u.u_error = wait1(0, (struct rusage *)0);
		return;
	}
	vtp = (struct vtimes *)u.u_ar0[R1];
	u.u_error = wait1(u.u_ar0[R0], &ru);
	if (u.u_error)
		return;
	getvtimes(&ru, &avt);
	(void) copyout((caddr_t)&avt, (caddr_t)vtp, sizeof (struct vtimes));
}

getvtimes(aru, avt)
	register struct rusage *aru;
	register struct vtimes *avt;
{

	avt->vm_utime = scale60(&aru->ru_utime);
	avt->vm_stime = scale60(&aru->ru_stime);
	avt->vm_idsrss = ((aru->ru_idrss+aru->ru_isrss) / hz) * 60;
	avt->vm_ixrss = aru->ru_ixrss / hz * 60;
	avt->vm_maxrss = aru->ru_maxrss;
	avt->vm_majflt = aru->ru_majflt;
	avt->vm_minflt = aru->ru_minflt;
	avt->vm_nswap = aru->ru_nswap;
	avt->vm_inblk = aru->ru_inblock;
	avt->vm_oublk = aru->ru_oublock;
}

ovlimit()
{

	u.u_error = EACCES;
}

okill()
{
	register struct a {
		int	pid;
		int	signo;
	} *uap = (struct a *)u.u_ap;

	u.u_error = kill1(uap->signo < 0,
		uap->signo < 0 ? -uap->signo : uap->signo, uap->pid);
}

ossig()
{
	struct a {
		int	signo;
		int	(*fun)();
	} *uap = (struct a *)u.u_ap;
	register int a, (*f)();
	struct proc *p = u.u_procp;

	f = uap->fun;
	a = uap->signo;
	/*
	 * Kill processes trying to use job control facilities
	 * (this'll help us find any vestiges of the old stuff).
	 */
	if ((a &~ 0377) ||
	    (f != SIG_DFL && f != SIG_IGN && ((int)f) & 1)) {
		psignal(p, SIGSYS);
		return;
	}
	if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP ||
	    a == SIGCONT && (f == SIG_IGN || f == SIG_HOLD)) {
		u.u_error = EINVAL;
		return;
	}
	setsignal(a, f, 0);
	p->p_flag |= SOUSIG;		/* mark as simulating old stuff */
}
#endif
Commit	Line	Data
dd012d1e	1	/* kern_xxx.c 4.3 83/06/02 */
3dbbffbd SL	2
	3	#include "../h/param.h"
	4	#include "../h/systm.h"
	5	#include "../h/dir.h"
	6	#include "../h/user.h"
	7	#include "../h/kernel.h"
	8	#include "../h/proc.h"
	9	#include "../h/reboot.h"
3dbbffbd SL	10
	11	gethostid()
	12	{
	13
	14	u.u_r.r_val1 = hostid;
	15	}
	16
	17	sethostid()
	18	{
	19	struct a {
	20	int hostid;
	21	} uap = (struct a )u.u_ap;
	22
	23	if (suser())
	24	hostid = uap->hostid;
	25	}
	26
	27	gethostname()
	28	{
	29	register struct a {
	30	char *hostname;
	31	int len;
	32	} uap = (struct a )u.u_ap;
	33	register u_int len;
	34
	35	len = uap->len;
	36	if (len > hostnamelen + 1)
	37	len = hostnamelen + 1;
	38	u.u_error = copyout((caddr_t)hostname, (caddr_t)uap->hostname, len);
	39	}
	40
	41	sethostname()
	42	{
	43	register struct a {
	44	char *hostname;
	45	u_int len;
	46	} uap = (struct a )u.u_ap;
	47
	48	if (!suser())
	49	return;
	50	if (uap->len > sizeof (hostname) - 1) {
	51	u.u_error = EINVAL;
	52	return;
	53	}
	54	hostnamelen = uap->len;
	55	u.u_error = copyin((caddr_t)uap->hostname, hostname, uap->len);
	56	hostname[hostnamelen] = 0;
	57	}
	58
	59	reboot()
	60	{
	61	register struct a {
	62	int opt;
	63	};
	64
	65	if (suser())
	66	boot(RB_BOOT, ((struct a *)u.u_ap)->opt);
	67	}
	68
	69	#ifndef NOCOMPAT
02c45551 SL	70	#include "../h/quota.h"
02c45551 SL	71
3dbbffbd SL	72	osetuid()
	73	{
	74	register uid;
	75	register struct a {
	76	int uid;
	77	} *uap;
	78
	79	uap = (struct a *)u.u_ap;
	80	uid = uap->uid;
	81	if (u.u_ruid == uid \|\| u.u_uid == uid \|\| suser()) {
	82	#ifdef QUOTA
	83	if (u.u_quota->q_uid != uid) {
	84	qclean();
	85	qstart(getquota(uid, 0, 0));
	86	}
	87	#endif
	88	u.u_uid = uid;
	89	u.u_procp->p_uid = uid;
	90	u.u_ruid = uid;
	91	}
	92	}
	93
	94	osetgid()
	95	{
	96	register gid;
	97	register struct a {
	98	int gid;
	99	} *uap;
	100
	101	uap = (struct a *)u.u_ap;
	102	gid = uap->gid;
	103	if (u.u_rgid == gid \|\| u.u_gid == gid \|\| suser()) {
	104	leavegroup(u.u_rgid);
	105	(void) entergroup(gid);
	106	u.u_gid = gid;
	107	u.u_rgid = gid;
	108	}
	109	}
	110
	111	/*
	112	* Pid of zero implies current process.
	113	* Pgrp -1 is getpgrp system call returning
	114	* current process group.
	115	*/
	116	osetpgrp()
	117	{
	118	register struct proc *p;
	119	register struct a {
	120	int pid;
	121	int pgrp;
	122	} *uap;
	123
	124	uap = (struct a *)u.u_ap;
	125	if (uap->pid == 0)
	126	p = u.u_procp;
	127	else {
	128	p = pfind(uap->pid);
	129	if (p == 0) {
	130	u.u_error = ESRCH;
	131	return;
	132	}
	133	}
	134	if (uap->pgrp <= 0) {
	135	u.u_r.r_val1 = p->p_pgrp;
136	return;
137	}
138	if (p->p_uid != u.u_uid && u.u_uid && !inferior(p)) {
139	u.u_error = EPERM;
140	return;
141	}
142	p->p_pgrp = uap->pgrp;
143	}
144
145	otime()
146	{
147
148	u.u_r.r_time = time.tv_sec;
149	}
150
151	ostime()
152	{
153	register struct a {
154	int time;
155	} uap = (struct a )u.u_ap;
156	struct timeval tv;
157
158	tv.tv_sec = uap->time;
159	tv.tv_usec = 0;
160	setthetime(&tv);
161	}
162
163	/* from old timeb.h */
164	struct timeb {
165	time_t time;
166	u_short millitm;
167	short timezone;
168	short dstflag;
169	};
170
171	oftime()
172	{
173	register struct a {
174	struct timeb *tp;
175	} *uap;
176	struct timeb tb;
177
178	uap = (struct a *)u.u_ap;
179	(void) spl7();
180	tb.time = time.tv_sec;
181	tb.millitm = time.tv_usec / 1000;
182	(void) spl0();
183	tb.timezone = tz.tz_minuteswest;
184	tb.dstflag = tz.tz_dsttime;
185	u.u_error = copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb));
186	}
187
188	oalarm()
189	{
190	register struct a {
191	int deltat;
192	} uap = (struct a )u.u_ap;
193	register struct proc *p = u.u_procp;
194	int s = spl7();
195
196	untimeout(realitexpire, (caddr_t)p);
197	timerclear(&p->p_realtimer.it_interval);
198	u.u_r.r_val1 = 0;
199	if (timerisset(&p->p_realtimer.it_value) &&
200	timercmp(&p->p_realtimer.it_value, &time, >))
201	u.u_r.r_val1 = p->p_realtimer.it_value.tv_sec - time.tv_sec;
202	if (uap->deltat == 0) {
203	timerclear(&p->p_realtimer.it_value);
204	splx(s);
205	return;
206	}
207	p->p_realtimer.it_value = time;
208	p->p_realtimer.it_value.tv_sec += uap->deltat;
209	timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
210	splx(s);
211	}
212
213	onice()
214	{
215	register struct a {
216	int niceness;
217	} uap = (struct a )u.u_ap;
218	register struct proc *p = u.u_procp;
219
220	donice(p, (p->p_nice-NZERO)+uap->niceness);
221	}
222
223	#include "../h/times.h"
224
225	otimes()
226	{
227	register struct a {
228	struct tms *tmsb;
229	} uap = (struct a )u.u_ap;
230	struct tms atms;
231
232	atms.tms_utime = scale60(&u.u_ru.ru_utime);
233	atms.tms_stime = scale60(&u.u_ru.ru_stime);
234	atms.tms_cutime = scale60(&u.u_cru.ru_utime);
235	atms.tms_cstime = scale60(&u.u_cru.ru_stime);
236	u.u_error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
237	}
238
239	scale60(tvp)
240	register struct timeval *tvp;
241	{
242
243	return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
244	}
245
246	#include "../h/vtimes.h"
247
248	ovtimes()
249	{
250	register struct a {
251	struct vtimes *par;
252	struct vtimes *chi;
253	} uap = (struct a )u.u_ap;
254	struct vtimes avt;
255
256	if (uap->par) {
257	getvtimes(&u.u_ru, &avt);
258	u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->par,
259	sizeof (avt));
260	if (u.u_error)
261	return;
262	}
263	if (uap->chi) {
264	getvtimes(&u.u_cru, &avt);
265	u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->chi,
266	sizeof (avt));
267	if (u.u_error)
268	return;
269	}
270	}
271
02c45551 SL	272	#include "../machine/psl.h"
	273	#include "../machine/reg.h"
	274
	275	owait()
	276	{
	277	struct rusage ru;
	278	struct vtimes *vtp, avt;
	279
	280	if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) {
	281	u.u_error = wait1(0, (struct rusage *)0);
	282	return;
	283	}
	284	vtp = (struct vtimes *)u.u_ar0[R1];
	285	u.u_error = wait1(u.u_ar0[R0], &ru);
	286	if (u.u_error)
	287	return;
	288	getvtimes(&ru, &avt);
	289	(void) copyout((caddr_t)&avt, (caddr_t)vtp, sizeof (struct vtimes));
	290	}
	291
3dbbffbd SL	292	getvtimes(aru, avt)
	293	register struct rusage *aru;
	294	register struct vtimes *avt;
	295	{
	296
	297	avt->vm_utime = scale60(&aru->ru_utime);
	298	avt->vm_stime = scale60(&aru->ru_stime);
	299	avt->vm_idsrss = ((aru->ru_idrss+aru->ru_isrss) / hz) * 60;
	300	avt->vm_ixrss = aru->ru_ixrss / hz * 60;
	301	avt->vm_maxrss = aru->ru_maxrss;
	302	avt->vm_majflt = aru->ru_majflt;
	303	avt->vm_minflt = aru->ru_minflt;
	304	avt->vm_nswap = aru->ru_nswap;
	305	avt->vm_inblk = aru->ru_inblock;
	306	avt->vm_oublk = aru->ru_oublock;
	307	}
	308
	309	ovlimit()
	310	{
	311
	312	u.u_error = EACCES;
	313	}
	314
	315	okill()
	316	{
	317	register struct a {
	318	int pid;
	319	int signo;
	320	} uap = (struct a )u.u_ap;
	321
	322	u.u_error = kill1(uap->signo < 0,
	323	uap->signo < 0 ? -uap->signo : uap->signo, uap->pid);
	324	}
	325
	326	ossig()
	327	{
3dbbffbd SL	328	struct a {
	329	int signo;
	330	int (*fun)();
dd012d1e SL	331	} uap = (struct a )u.u_ap;
	332	register int a, (*f)();
	333	struct proc *p = u.u_procp;
3dbbffbd	334
3dbbffbd	335	f = uap->fun;
dd012d1e	336	a = uap->signo;
3dbbffbd	337	/*
dd012d1e SL	338	* Kill processes trying to use job control facilities
dd012d1e SL	339	* (this'll help us find any vestiges of the old stuff).
3dbbffbd	340	*/
dd012d1e SL	341	if ((a &~ 0377) \|\|
	342	(f != SIG_DFL && f != SIG_IGN && ((int)f) & 1)) {
	343	psignal(p, SIGSYS);
	344	return;
	345	}
	346	if (a <= 0 \|\| a >= NSIG \|\| a == SIGKILL \|\| a == SIGSTOP \|\|
	347	a == SIGCONT && (f == SIG_IGN \|\| f == SIG_HOLD)) {
	348	u.u_error = EINVAL;
	349	return;
3dbbffbd	350	}
dd012d1e SL	351	setsignal(a, f, 0);
dd012d1e SL	352	p->p_flag \|= SOUSIG; /* mark as simulating old stuff */
3dbbffbd SL	353	}
3dbbffbd SL	354	#endif