![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / os|
Return to sys4.c CVS log | Up to [Research Unix] / researchv10dc / lsys / os |
1.1 root 1: /* sys4.c 4.10 81/07/04 */
2:
3: #include "sys/param.h"
4: #include "sys/systm.h"
5: #include "sys/user.h"
6: #include "sys/inode.h"
7: #include "sys/proc.h"
8: #include "sys/clock.h"
9: #include "sys/timeb.h"
10: #include "sys/times.h"
11: #include "sys/file.h"
12:
13: /*
14: * Everything in this file is a routine implementing a system call.
15: */
16:
17: /*
18: * return the current time (old-style entry)
19: */
20: gtime()
21: {
22: u.u_r.r_time = time;
23: clkcheck();
24: }
25:
26: /*
27: * New time entry-- return TOD with milliseconds, timezone,
28: * DST flag
29: */
30: ftime()
31: {
32: register struct a {
33: struct timeb *tp;
34: } *uap;
35: struct timeb t;
36: register unsigned ms;
37: extern int timezone, dstflag;
38:
39: uap = (struct a *)u.u_ap;
40: (void) spl7();
41: t.time = time;
42: ms = lbolt;
43: (void) spl0();
44: if (ms > HZ) {
45: ms -= HZ;
46: t.time++;
47: }
48: t.millitm = (1000*ms)/HZ;
49: t.timezone = timezone;
50: t.dstflag = dstflag;
51: if (copyout((caddr_t)&t, (caddr_t)uap->tp, sizeof(t)))
52: u.u_error = EFAULT;
53: clkcheck();
54: }
55:
56: /*
57: * Set the time
58: */
59: stime()
60: {
61: register struct a {
62: time_t time;
63: } *uap;
64: extern time_t bootime;
65:
66: uap = (struct a *)u.u_ap;
67: if(suser()) {
68: bootime += uap->time - time; /* silly */
69: time = uap->time;
70: clkset();
71: }
72: }
73:
74: setuid()
75: {
76: register uid;
77: register struct a {
78: int uid;
79: } *uap;
80:
81: uap = (struct a *)u.u_ap;
82: uid = uap->uid;
83: if(u.u_ruid == uid || u.u_uid == uid || suser()) {
84: u.u_uid = uid;
85: u.u_procp->p_uid = uid;
86: u.u_ruid = uid;
87: }
88: }
89:
90: getuid()
91: {
92:
93: u.u_r.r_val1 = u.u_ruid;
94: u.u_r.r_val2 = u.u_uid;
95: }
96:
97: setruid()
98: {
99: register uid;
100: register struct a {
101: int uid;
102: } *uap;
103:
104: uap = (struct a *)u.u_ap;
105: uid = uap->uid;
106: if(suser())
107: u.u_ruid = uid;
108: }
109:
110: setgid()
111: {
112: register gid;
113: register struct a {
114: int gid;
115: } *uap;
116:
117: uap = (struct a *)u.u_ap;
118: gid = uap->gid;
119: if(u.u_rgid == gid || u.u_gid == gid || suser()) {
120: u.u_gid = gid;
121: u.u_rgid = gid;
122: }
123: }
124:
125: getgid()
126: {
127:
128: u.u_r.r_val1 = u.u_rgid;
129: u.u_r.r_val2 = u.u_gid;
130: }
131:
132: setgroups()
133: {
134: register struct a {
135: u_int gidsetsize;
136: short *gidset;
137: } *uap = (struct a *)u.u_ap;
138: register short *gp;
139:
140: if (!suser())
141: return;
142: if (uap->gidsetsize > sizeof u.u_groups / sizeof u.u_groups[0]) {
143: u.u_error = EINVAL;
144: return;
145: }
146: if (copyin((caddr_t)uap->gidset, (caddr_t)u.u_groups,
147: uap->gidsetsize * sizeof u.u_groups[0]) < 0) {
148: u.u_error = EFAULT;
149: return;
150: }
151: for (gp = &u.u_groups[uap->gidsetsize] ; gp < &u.u_groups[NGROUPS]; gp++)
152: *gp = NOGROUP;
153: }
154:
155: /*
156: * Check if gid is a member of the group set.
157: */
158: groupmember(gid)
159: short gid;
160: {
161: register short *gp;
162:
163: if (u.u_gid == gid)
164: return (1);
165: for (gp = u.u_groups; gp < &u.u_groups[NGROUPS] && *gp != NOGROUP; gp++)
166: if (*gp == gid)
167: return (1);
168: return (0);
169: }
170:
171: getgroups()
172: {
173: register struct a {
174: u_int gidsetsize;
175: short *gidset;
176: } *uap = (struct a *)u.u_ap;
177: register short *gp;
178:
179: for (gp = &u.u_groups[NGROUPS]; gp > u.u_groups; gp--)
180: if (gp[-1] != NOGROUP)
181: break;
182: if (uap->gidsetsize < gp - u.u_groups) {
183: u.u_error = EINVAL;
184: return;
185: }
186: uap->gidsetsize = gp - u.u_groups;
187: if (copyout((caddr_t)u.u_groups, (caddr_t)uap->gidset,
188: uap->gidsetsize * sizeof u.u_groups[0]) < 0) {
189: u.u_error = EFAULT;
190: return;
191: }
192: u.u_r.r_val1 = uap->gidsetsize;
193: }
194:
195: getpid()
196: {
197: u.u_r.r_val1 = u.u_procp->p_pid;
198: u.u_r.r_val2 = u.u_procp->p_ppid;
199: }
200:
201: sync()
202: {
203:
204: update();
205: }
206:
207: nice()
208: {
209: register n;
210: register struct a {
211: int niceness;
212: } *uap;
213:
214: uap = (struct a *)u.u_ap;
215: n = uap->niceness + u.u_procp->p_nice;
216: if(n >= 2*NZERO)
217: n = 2*NZERO -1;
218: if(n < 0)
219: n = 0;
220: if (n < u.u_procp->p_nice && !suser())
221: return;
222: u.u_procp->p_nice = n;
223: }
224:
225: /*
226: * Unlink system call.
227: * Hard to avoid races here, especially
228: * in unlinking directories.
229: */
230: unlink()
231: {
232: struct a {
233: char *fname;
234: };
235: struct argnamei nmarg;
236:
237: nmarg = nilargnamei;
238: nmarg.flag = NI_DEL;
239: (void) namei(((struct a *)u.u_ap)->fname, SEGUDATA, &nmarg, 0);
240: }
241: chdir()
242: {
243: chdirec(&u.u_cdir);
244: }
245:
246: chroot()
247: {
248: if (suser())
249: chdirec(&u.u_rdir);
250: }
251:
252: chdirec(ipp)
253: register struct inode **ipp;
254: {
255: register struct inode *ip;
256: struct a {
257: char *fname;
258: };
259:
260: ip = namei(((struct a *)u.u_ap)->fname, SEGUDATA, &nilargnamei, 1);
261: if(ip == NULL)
262: return;
263: if((ip->i_mode&IFMT) != IFDIR) {
264: u.u_error = ENOTDIR;
265: goto bad;
266: }
267: if(access(ip, IEXEC))
268: goto bad;
269: prele(ip);
270: if (*ipp) {
271: plock(*ipp);
272: iput(*ipp);
273: }
274: *ipp = ip;
275: return;
276:
277: bad:
278: iput(ip);
279: }
280:
281: fchmod()
282: { register struct file *fp;
283: register struct a {
284: int fd;
285: int fmode;
286: } *uap;
287:
288: uap = (struct a *)u.u_ap;
289: if((fp = getf(uap->fd)) == NULL) {
290: u.u_error = EBADF;
291: return;
292: }
293: chmod1(fp->f_inode, uap->fmode);
294: }
295:
296: chmod()
297: {
298: register struct inode *ip;
299: register struct a {
300: char *fname;
301: int fmode;
302: } *uap;
303:
304: uap = (struct a *)u.u_ap;
305: if ((ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1)) == NULL)
306: return;
307: chmod1(ip, uap->fmode);
308: iput(ip);
309: }
310:
311: chmod1(ip, mode)
312: register struct inode *ip;
313: {
314:
315: if (accowner(ip) == 0)
316: return;
317: ip->i_mode &= ~07777;
318: if (!(mode&ICONC) && u.u_uid!=0 && !groupmember(ip->i_gid))
319: mode &= ~ISGID;
320: ip->i_mode |= mode&07777;
321: ip->i_flag |= ICHG;
322: }
323:
324: /* chown with file descriptor*/
325: fchown()
326: { register struct file *fp;
327: register struct a {
328: int fd;
329: int uid;
330: int gid;
331: } *uap;
332:
333: uap = (struct a *)u.u_ap;
334: if((fp = getf(uap->fd)) == NULL) {
335: u.u_error = EBADF;
336: return;
337: }
338: chown1(fp->f_inode, uap->uid, uap->gid);
339: }
340:
341: chown()
342: {
343: register struct inode *ip;
344: register struct a {
345: char *fname;
346: int uid;
347: int gid;
348: } *uap;
349:
350: uap = (struct a *)u.u_ap;
351: if ((ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1)) == NULL)
352: return;
353: chown1(ip, uap->uid, uap->gid);
354: iput(ip);
355: }
356:
357: chown1(ip, uid, gid)
358: register struct inode *ip;
359: {
360:
361: if (accowner(ip) == 0)
362: return;
363: if(u.u_uid){
364: if((ip->i_uid != uid) || !groupmember(gid)){
365: u.u_error = EPERM;
366: return;
367: }
368: if((ip->i_mode&ICONC)==0 && gid != ip->i_gid)
369: ip->i_mode &=~ ISGID;
370: }
371: ip->i_uid = uid;
372: ip->i_gid = gid;
373: ip->i_flag |= ICHG;
374: }
375:
376: ssig()
377: {
378: register int (*f)();
379: struct a {
380: int signo;
381: int (*fun)();
382: } *uap;
383: register struct proc *p = u.u_procp;
384: register a;
385: register long sigmask;
386:
387: uap = (struct a *)u.u_ap;
388: a = uap->signo & SIGNUMMASK;
389: f = uap->fun;
390: if(a<=0 || a>=NSIG || a==SIGKILL || a==SIGSTOP) {
391: u.u_error = EINVAL;
392: return;
393: }
394: u.u_r.r_val1 = (int)u.u_signal[a];
395: sigmask = SIGMASK(a);
396: (void) spl6();
397: if (u.u_signal[a] == SIG_IGN)
398: p->p_sig &= ~sigmask; /* never to be seen again */
399: u.u_signal[a] = f;
400: if (f == SIG_DFL)
401: P_SETDFL(p, sigmask);
402: else if (f == SIG_IGN)
403: P_SETIGN(p, sigmask);
404: else if (f == SIG_HOLD)
405: P_SETHOLD(p, sigmask);
406: else
407: P_SETCATCH(p, sigmask);
408: (void) spl0();
409: if (uap->signo & SIGDOPAUSE)
410: pause();
411: }
412:
413: kill()
414: {
415: register struct a {
416: int pid;
417: int signo;
418: } *uap;
419:
420: u.u_error = ESRCH; /* default error */
421: uap = (struct a *)u.u_ap;
422: if (uap->signo > NSIG || uap->signo < 0) {
423: u.u_error = EINVAL;
424: return;
425: }
426: if (uap->pid == -1)
427: killall(uap->signo);
428: else if(uap->pid > 0)
429: killproc(uap->pid, uap->signo);
430: else if (uap->pid < 0)
431: killpgrp(-uap->pid, uap->signo);
432: else
433: killpgrp(u.u_procp->p_pgrp, uap->signo);
434: }
435:
436: /*
437: * kill a single process
438: */
439: killproc(pid, sig)
440: register int pid, sig;
441: {
442: register struct proc *p;
443:
444: for (p = proc; p < procNPROC; p++)
445: if (p->p_stat && p->p_pid == pid)
446: break;
447: if (p == procNPROC)
448: return;
449: if (u.u_uid && u.u_uid != p->p_uid) { /* no permission */
450: u.u_error = EPERM;
451: return;
452: }
453: if (sig != 0) /* real signal? */
454: psignal(p, sig); /* yes, send it */
455: u.u_error = 0;
456: }
457:
458: /*
459: * Kill all processes within a process group but not system processes.
460: * SIGCONT may be sent to any descendants (can you say hack?).
461: */
462: killpgrp(pgrp, sig)
463: register int pgrp, sig;
464: {
465: register struct proc *p;
466:
467: for(p = proc; p < procNPROC; p++) {
468: if(p->p_stat == 0)
469: continue; /* non-existent */
470: if (p->p_pgrp!=pgrp || p->p_flag&SSYS)
471: continue;
472: if(u.u_uid != 0 && u.u_uid != p->p_uid &&
473: (sig != SIGCONT || !inferior(p)))
474: continue;
475: u.u_error = 0;
476: if (sig != 0) /* real signal? */
477: psignal(p, sig); /* yes, send it */
478: }
479: }
480:
481: /*
482: * Kill all processes except the system processes and the current process
483: */
484: killall(sig)
485: register int sig;
486: {
487: register struct proc *p;
488:
489: if (!suser())
490: return;
491: for(p = proc; p < procNPROC; p++) {
492: if(p->p_stat == 0)
493: continue;
494: if (p->p_flag&SSYS || p==u.u_procp)
495: continue;
496: u.u_error = 0;
497: psignal(p, sig);
498: }
499: }
500:
501: times()
502: {
503: register struct a {
504: time_t (*times)[4];
505: } *uap;
506: struct tms tms;
507:
508: tms.tms_utime = u.u_vm.vm_utime;
509: tms.tms_stime = u.u_vm.vm_stime;
510: tms.tms_cutime = u.u_cvm.vm_utime;
511: tms.tms_cstime = u.u_cvm.vm_stime;
512: uap = (struct a *)u.u_ap;
513: if (copyout((caddr_t)&tms, (caddr_t)uap->times, sizeof(struct tms)) < 0)
514: u.u_error = EFAULT;
515: }
516:
517: profil()
518: {
519: register struct a {
520: short *bufbase;
521: unsigned bufsize;
522: unsigned pcoffset;
523: unsigned pcscale;
524: } *uap;
525:
526: uap = (struct a *)u.u_ap;
527: u.u_prof.pr_base = uap->bufbase;
528: u.u_prof.pr_size = uap->bufsize;
529: u.u_prof.pr_off = uap->pcoffset;
530: u.u_prof.pr_scale = uap->pcscale;
531: }
532:
533: /*
534: * alarm clock signal
535: */
536: alarm()
537: {
538: register struct proc *p;
539: register c;
540: register struct a {
541: int deltat;
542: } *uap;
543:
544: uap = (struct a *)u.u_ap;
545: p = u.u_procp;
546: c = p->p_clktim;
547: if (uap->deltat > 65535L)
548: uap->deltat = 65535;
549: p->p_clktim = uap->deltat;
550: u.u_r.r_val1 = c;
551: }
552:
553: /*
554: * indefinite wait.
555: * no one should wakeup(&u)
556: */
557: pause()
558: {
559:
560: for(;;)
561: sleep((caddr_t)&u, PSLEP);
562: }
563:
564: /*
565: * mode mask for creation of files
566: */
567: umask()
568: {
569: register struct a {
570: int mask;
571: } *uap;
572: register t;
573:
574: uap = (struct a *)u.u_ap;
575: t = u.u_cmask;
576: u.u_cmask = uap->mask & 0777;
577: u.u_r.r_val1 = t;
578: }
579:
580: /*
581: * Set IUPD and IACC times on file.
582: * Can't set ICHG.
583: */
584: utime()
585: {
586: register struct a {
587: char *fname;
588: time_t *tptr;
589: } *uap;
590: register struct inode *ip;
591: time_t tv[2];
592:
593: uap = (struct a *)u.u_ap;
594: if ((ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1)) == NULL)
595: return;
596: if (accowner(ip) == 0) {
597: iput(ip);
598: return;
599: }
600: if (copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof(tv))) {
601: u.u_error = EFAULT;
602: } else {
603: ip->i_flag |= IACC|IUPD|ICHG;
604: iupdat(ip, &tv[0], &tv[1], 0);
605: }
606: iput(ip);
607: }
608:
609: /*
610: * Setpgrp on specified process and its descendants.
611: * Pid of zero implies current process.
612: * Pgrp -1 is getpgrp system call returning
613: * current process group.
614: */
615: setpgrp()
616: {
617: register struct proc *top;
618: register struct a {
619: int pid;
620: int pgrp;
621: } *uap;
622:
623: uap = (struct a *)u.u_ap;
624: uap->pid = (short)uap->pid; /* else 0x10000 would make pgrp 0 */
625: uap->pgrp = (short)uap->pgrp;
626: if (uap->pid == 0)
627: top = u.u_procp;
628: else {
629: top = pfind(uap->pid);
630: if (top == 0) {
631: u.u_error = ESRCH;
632: return;
633: }
634: }
635: if (uap->pgrp == 0 && !suser())
636: return;
637:
638: if (uap->pgrp < 0) {
639: u.u_r.r_val1 = top->p_pgrp;
640: return;
641: }
642: if (top->p_uid != u.u_uid && u.u_uid && !inferior(top))
643: u.u_error = EPERM;
644: else
645: top->p_pgrp = uap->pgrp;
646: }
647:
648: spgrp(top, npgrp)
649: register struct proc *top;
650: {
651: register struct proc *pp, *p;
652: int f = 0;
653:
654: for (p = top; npgrp == -1 || u.u_uid == p->p_uid ||
655: !u.u_uid || inferior(p); p = pp) {
656: if (npgrp == -1) {
657: #define bit(a) (1<<(a-1))
658: p->p_sig &= ~(bit(SIGTSTP)|bit(SIGTTIN)|bit(SIGTTOU));
659: } else
660: p->p_pgrp = npgrp;
661: f++;
662: /*
663: * Search for children.
664: */
665: for (pp = proc; pp < procNPROC; pp++)
666: if (pp->p_stat != 0 && pp->p_pptr == p)
667: goto cont;
668: /*
669: * Search for siblings.
670: */
671: for (; p != top; p = p->p_pptr)
672: for (pp = p + 1; pp < procNPROC; pp++)
673: if (pp->p_stat != 0 && pp->p_pptr == p->p_pptr)
674: goto cont;
675: break;
676: cont:
677: ;
678: }
679: return (f);
680: }
681:
682: /*
683: * Is p an inferior of the current process?
684: */
685: inferior(p)
686: register struct proc *p;
687: {
688:
689: for (; p != u.u_procp; p = p->p_pptr)
690: if (p < &proc[SYSPIDS])
691: return (0);
692: return (1);
693: }
694:
695: sysboot()
696: {
697: register struct a {
698: int opt;
699: };
700:
701: if (suser())
702: boot(((struct a *)u.u_ap)->opt);
703: }
704:
705: /*
706: * lock user into core as much
707: * as possible. swapping may still
708: * occur if core grows.
709: */
710: syslock()
711: {
712: register struct proc *p;
713: register struct a {
714: int flag;
715: } *uap;
716:
717: uap = (struct a *)u.u_ap;
718: if(suser()) {
719: p = u.u_procp;
720: p->p_flag &= ~SULOCK;
721: if(uap->flag)
722: p->p_flag |= SULOCK;
723: }
724: }
725:
726: /*
727: * nap for n clock ticks
728: */
729: #define MAXNAP 120
730: nap()
731: {
732: register struct a {
733: int nticks;
734: } *uap;
735: register int n;
736:
737: uap = (struct a *)u.u_ap;
738: n = uap->nticks;
739: if (n < 0)
740: n = 0;
741: if (n > MAXNAP)
742: n = MAXNAP;
743: delay (n);
744: }
745:
746: /*
747: * get/set user's login name
748: */
749:
750: getlogname()
751: {
752: register struct a {
753: char *name;
754: int flag;
755: } *uap;
756:
757: uap = (struct a *)u.u_ap;
758: if (uap->flag == 0) {
759: if (copyout((caddr_t)u.u_logname, (caddr_t)uap->name, sizeof(u.u_logname)) < 0)
760: u.u_error = EFAULT;
761: return;
762: }
763: if (suser() == 0)
764: return;
765: if (copyin((caddr_t)uap->name, (caddr_t)u.u_logname, sizeof(u.u_logname)))
766: u.u_error = EFAULT;
767: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.