Commit | Line | Data |
---|---|---|
457aa395 | 1 | /* kern_xxx.c 4.4 83/06/09 */ |
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" |
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 | 331 | } *uap = (struct a *)u.u_ap; |
457aa395 SL |
332 | register int a; |
333 | struct sigvec vec; | |
334 | register struct sigvec *sv = &vec; | |
dd012d1e | 335 | struct proc *p = u.u_procp; |
3dbbffbd | 336 | |
dd012d1e | 337 | a = uap->signo; |
457aa395 | 338 | sv->sv_handler = uap->fun; |
3dbbffbd | 339 | /* |
dd012d1e SL |
340 | * Kill processes trying to use job control facilities |
341 | * (this'll help us find any vestiges of the old stuff). | |
3dbbffbd | 342 | */ |
dd012d1e | 343 | if ((a &~ 0377) || |
457aa395 SL |
344 | (sv->sv_handler != SIG_DFL && sv->sv_handler != SIG_IGN && |
345 | ((int)sv->sv_handler) & 1)) { | |
dd012d1e SL |
346 | psignal(p, SIGSYS); |
347 | return; | |
348 | } | |
349 | if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP || | |
457aa395 | 350 | a == SIGCONT && sv->sv_handler == SIG_IGN) { |
dd012d1e SL |
351 | u.u_error = EINVAL; |
352 | return; | |
3dbbffbd | 353 | } |
457aa395 SL |
354 | sv->sv_mask = 0; |
355 | sv->sv_onstack = 0; | |
356 | u.u_r.r_val1 = (int)u.u_signal[a]; | |
357 | setsigvec(a, sv); | |
dd012d1e | 358 | p->p_flag |= SOUSIG; /* mark as simulating old stuff */ |
3dbbffbd SL |
359 | } |
360 | #endif |