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

/*
 * Copyright (c) 1982, 1986 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)kern_xxx.c	7.2 (Berkeley) %G%
 */

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

gethostid()
{

	u.u_r.r_val1 = hostid;
}

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

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

gethostname()
{
	register struct a {
		char	*hostname;
		u_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(((struct a *)u.u_ap)->opt);
}

#ifdef COMPAT
#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;
	int s;

	uap = (struct a *)u.u_ap;
	s = splhigh();
	tb.time = time.tv_sec;
	tb.millitm = time.tv_usec / 1000;
	splx(s);
	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 = splhigh();

	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;
}

ossig()
{
	struct a {
		int	signo;
		int	(*fun)();
	} *uap = (struct a *)u.u_ap;
	register int a;
	struct sigvec vec;
	register struct sigvec *sv = &vec;
	struct proc *p = u.u_procp;

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