![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / os|
Return to sys2.c CVS log | Up to [Research Unix] / researchv10no / sys / os |
1.1 root 1: /* sys2.c 4.7 81/04/13 */
2:
3: #include "sys/param.h"
4: #include "sys/systm.h"
5: #include "sys/user.h"
6: #include "sys/file.h"
7: #include "sys/inode.h"
8: #include "sys/pte.h"
9: #include "sys/vm.h"
10: #include "sys/buf.h"
11: #include "sys/proc.h"
12: #include "sys/conf.h"
13:
14: /*
15: * READ AND WRITE ARE NEAR DUPLICATES OF EACH OTHER TO SAVE
16: * AS MUCH TIME AS POSSIBLE.
17: */
18:
19: /*
20: * read system call
21: */
22: read()
23: {
24: register struct file *fp;
25: register struct inode *ip;
26: register struct a {
27: int fdes;
28: char *cbuf;
29: unsigned count;
30: } *uap;
31:
32: uap = (struct a *)u.u_ap;
33: if ((int)uap->count < 0) {
34: u.u_error = EINVAL;
35: return;
36: }
37: if ((fp = getf(uap->fdes)) == NULL) {
38: u.u_error = EBADF;
39: return;
40: }
41: if((fp->f_flag&FREAD) == 0) {
42: if((fp->f_flag & FHUNGUP) == 0) /* EOF on hungup chans */
43: u.u_error = EBADF;
44: else if (++u.u_nbadio > 64) {
45: if (u.u_nbadio > 128)
46: psignal(u.u_procp, SIGKILL);
47: else
48: psignal(u.u_procp, SIGPIPE);
49: }
50: return;
51: }
52: u.u_base = (caddr_t)uap->cbuf;
53: u.u_count = uap->count;
54: u.u_segflg = SEGUDATA;
55: if (setjmp(u.u_qsav)) {
56: if (u.u_count == uap->count)
57: u.u_error = EINTR;
58: } else {
59: ip = fp->f_inode;
60: u.u_offset = fp->f_offset;
61: if((ip->i_mode&(IFCHR&IFBLK)) == 0 && ip->i_sptr==NULL) {
62: plock(ip);
63: readi(ip);
64: prele(ip);
65: } else
66: readi(ip);
67: fp->f_offset = Lladd(fp->f_offset, uap->count-u.u_count);
68: }
69: u.u_r.r_val1 = uap->count-u.u_count;
70: }
71:
72: /*
73: * write system call
74: */
75: write()
76: {
77: register struct file *fp;
78: register struct inode *ip;
79: register struct a {
80: int fdes;
81: char *cbuf;
82: unsigned count;
83: } *uap;
84:
85: uap = (struct a *)u.u_ap;
86: if ((int)uap->count < 0) {
87: u.u_error = EINVAL;
88: return;
89: }
90: if ((fp = getf(uap->fdes)) == NULL) {
91: u.u_error = EBADF;
92: return;
93: }
94: if((fp->f_flag&FWRITE) == 0) {
95: if (fp->f_flag&FHUNGUP) {
96: u.u_error = EPIPE;
97: psignal(u.u_procp, SIGPIPE);
98: return;
99: }
100: u.u_error = EBADF;
101: return;
102: }
103: u.u_base = (caddr_t)uap->cbuf;
104: u.u_count = uap->count;
105: u.u_segflg = SEGUDATA;
106: if (setjmp(u.u_qsav)) {
107: if (u.u_count == uap->count)
108: u.u_error = EINTR;
109: } else {
110: ip = fp->f_inode;
111: u.u_offset = fp->f_offset;
112: if((ip->i_mode&(IFCHR&IFBLK)) == 0 && ip->i_sptr==0) {
113: plock(ip);
114: writei(ip);
115: prele(ip);
116: } else
117: writei(ip);
118: fp->f_offset = Lladd(fp->f_offset, uap->count-u.u_count);
119: }
120: u.u_r.r_val1 = uap->count-u.u_count;
121: }
122:
123: /*
124: * open system call
125: */
126: open()
127: {
128: register struct inode *ip;
129: register struct a {
130: char *fname;
131: int rwmode;
132: } *uap;
133:
134: uap = (struct a *)u.u_ap;
135: ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1);
136: if(ip == NULL)
137: return;
138: open1(ip, ++uap->rwmode, 0);
139: }
140:
141: /*
142: * creat system call
143: */
144: creat()
145: {
146: register struct inode *ip;
147: register struct a {
148: char *fname;
149: int fmode;
150: } *uap;
151: struct argnamei nmarg;
152: short mode;
153:
154: uap = (struct a *)u.u_ap;
155: nmarg = nilargnamei;
156: nmarg.flag = NI_CREAT;
157: nmarg.un.mode = mode = uap->fmode & 07777 & ~u.u_cmask;
158: ip = namei(uap->fname, SEGUDATA, &nmarg, 1);
159: if(ip == NULL)
160: return;
161: open1(ip, FWRITE, (nmarg.un.mode == mode)? 1: 2);
162: }
163:
164: /*
165: * common code for open and creat.
166: * Check permissions, allocate an open file structure,
167: * and call the device open routine if any.
168: */
169: open1(ip, mode, trf)
170: register struct inode *ip;
171: register mode;
172: {
173: register struct file *fp;
174: int i;
175:
176: if(trf != 2) {
177: if(ip->i_count>1 && (ip->i_mode&ICONC))
178: concurrency(ip, mode);
179: if(mode&FREAD)
180: (void) access(ip, IREAD);
181: if(mode&FWRITE) {
182: (void) access(ip, IWRITE);
183: if((ip->i_mode&IFMT) == IFDIR)
184: u.u_error = EISDIR;
185: }
186: }
187: if(u.u_error)
188: goto out;
189: if(trf == 1)
190: (*fstypsw[ip->i_fstyp]->t_trunc)(ip);
191: prele(ip);
192: if ((fp = falloc()) == NULL)
193: goto out;
194: fp->f_flag = mode&(FREAD|FWRITE);
195: fp->f_inode = ip; /* dubious, but see io/fd.c */
196: i = u.u_r.r_val1;
197: if ((fp->f_inode = openi(ip, mode&(FREAD|FWRITE))) != NULL)
198: return;
199: u.u_ofile[i] = NULL;
200: fp->f_count--;
201: return;
202:
203: out:
204: iput(ip);
205: }
206:
207:
208: /* Mkdir system call */
209: mkdir()
210: {
211: register struct a {
212: char *fname;
213: int fmode;
214: } *uap;
215: struct argnamei nmarg;
216:
217: uap = (struct a *)u.u_ap;
218: nmarg = nilargnamei;
219: nmarg.flag = NI_MKDIR;
220: nmarg.un.mode = (uap->fmode & 0777 & ~u.u_cmask) | IFDIR;
221: (void)namei(uap->fname, SEGUDATA, &nmarg, 0);
222: }
223:
224: /* Rmdir system call */
225: rmdir()
226: { struct a {
227: char *fname;
228: };
229: struct argnamei nmarg;
230:
231: nmarg = nilargnamei;
232: nmarg.flag = NI_RMDIR;
233: (void) namei(((struct a *)u.u_ap)->fname, SEGUDATA, &nmarg, 0);
234: }
235:
236: /*
237: * Select system call.
238: */
239: int nselcoll;
240: int selwait;
241:
242: select()
243: {
244: register struct uap {
245: int nfd;
246: fd_set *rp, *wp;
247: int timo;
248: } *ap = (struct uap *)u.u_ap;
249: fd_set rd, wr, readable, writeable;
250: int nfds = 0;
251: time_t t = time;
252: int s, tsel, ncoll, rem;
253: unsigned len;
254: fd_set selscan();
255:
256: if (ap->nfd > NOFILE)
257: ap->nfd = NOFILE;
258: if (ap->nfd < 0) {
259: u.u_error = EBADF;
260: return;
261: }
262:
263: /* read in only as many words as we need */
264: len = ((ap->nfd+NBPW*NBBY-1)/(NBPW*NBBY))*NBPW;
265: if (ap->rp && copyin((caddr_t)ap->rp, (caddr_t)&rd, len))
266: return;
267: if (ap->wp && copyin((caddr_t)ap->wp, (caddr_t)&wr, len))
268: return;
269: retry:
270: ncoll = nselcoll;
271: u.u_procp->p_flag |= SSEL;
272: if (ap->rp)
273: readable = selscan(ap->nfd, &rd, &nfds, FREAD);
274: if (ap->wp)
275: writeable = selscan(ap->nfd, &wr, &nfds, FWRITE);
276: if (u.u_error)
277: goto done;
278: if (nfds)
279: goto done;
280: rem = (ap->timo+999)/1000 - (time - t);
281: if (ap->timo == 0 || rem <= 0)
282: goto done;
283: s = spl6();
284: if ((u.u_procp->p_flag & SSEL) == 0 || nselcoll != ncoll) {
285: u.u_procp->p_flag &= ~SSEL;
286: splx(s);
287: goto retry;
288: }
289: u.u_procp->p_flag &= ~SSEL;
290: tsel = tsleep((caddr_t)&selwait, PZERO+1, rem);
291: splx(s);
292: switch (tsel) {
293:
294: case TS_OK:
295: goto retry;
296:
297: case TS_SIG:
298: u.u_error = EINTR;
299: return;
300:
301: case TS_TIME:
302: break;
303: }
304: done:
305: u.u_r.r_val1 = nfds;
306: if (ap->rp)
307: (void)copyout((caddr_t)&readable, (caddr_t)ap->rp, len);
308: if (ap->wp)
309: (void)copyout((caddr_t)&writeable, (caddr_t)ap->wp, len);
310: }
311:
312: fd_set
313: selscan(nfd, fdsp, nfdp, flag)
314: int nfd;
315: fd_set *fdsp;
316: int *nfdp, flag;
317: {
318: struct file *fp;
319: struct inode *ip;
320: unsigned int off, i, fd, able;
321: unsigned long bits;
322: fd_set res;
323:
324: /* loop through all words of the set */
325: for (off=0; off<FDWORDS; off++) {
326:
327: /* loop once for each bit on in a word of the set */
328: res.fds_bits[off] = 0;
329: bits = fdsp->fds_bits[off];
330: while (i = ffs(bits)) {
331: fd = off*(NBPW*NBBY)+i-1;
332: if (fd >= nfd)
333: return res;
334: bits &= ~(1<<(i-1));
335: fp = u.u_ofile[fd];
336: if (fp == NULL) {
337: u.u_error = EBADF;
338: return res;
339: }
340: ip = fp->f_inode;
341: able = 1;
342: if (ip->i_sptr)
343: able = stselect(ip->i_sptr, flag, *nfdp);
344: if (able) {
345: res.fds_bits[off] |= (1<<(i-1));
346: (*nfdp)++;
347: }
348: }
349: }
350: return res;
351: }
352:
353: selwakeup(p, coll)
354: register struct proc *p;
355: int coll;
356: {
357: int s;
358:
359: if (coll) {
360: nselcoll++;
361: wakeup((caddr_t)&selwait);
362: }
363: if (p) {
364: s = spl6();
365: if (p->p_wchan == (caddr_t)&selwait)
366: setrun(p);
367: else
368: p->p_flag &= ~SSEL;
369: splx(s);
370: }
371: }
372:
373: /*
374: * close system call
375: */
376: close()
377: {
378: register struct file *fp;
379: register struct a {
380: int fdes;
381: } *uap;
382:
383: uap = (struct a *)u.u_ap;
384: fp = getf(uap->fdes);
385: if(fp == NULL) {
386: u.u_error = EBADF;
387: return;
388: }
389: u.u_ofile[uap->fdes] = NULL;
390: closef(fp);
391: }
392:
393: /*
394: * [l]seek system calls
395: */
396:
397: lseek()
398: {
399: doseek(1);
400: }
401:
402: seek()
403: {
404: doseek(0);
405: }
406:
407: doseek(islong)
408: {
409: register struct file *fp;
410: register struct a {
411: int fdes;
412: off_t off;
413: int sbase;
414: } *uap1;
415: register struct b {
416: int fdes;
417: llong_t off;
418: int sbase;
419: } *uap2;
420: llong_t off;
421: int fdes, sbase;
422:
423: if (islong) {
424: uap2 = (struct b *)u.u_ap;
425: fdes = uap2->fdes;
426: off = uap2->off;
427: sbase = uap2->sbase;
428: } else {
429: uap1 = (struct a *)u.u_ap;
430: fdes = uap1->fdes;
431: sbase = uap1->sbase;
432: off = ltoL(uap1->off);
433: if (sbase!=0) { /* signed offset when not w.r.t. base */
434: if (uap1->off<0)
435: off.hi = -1;
436: }
437: }
438: fp = getf(fdes);
439: if(fp == NULL) {
440: u.u_error = EBADF;
441: return;
442: }
443: if(fp->f_inode->i_sptr) {
444: u.u_error = ESPIPE;
445: return;
446: }
447: if(sbase == 1)
448: off = LLadd(fp->f_offset, off);
449: else if(sbase == 2)
450: off = Lladd(off, fp->f_inode->i_size);
451: fp->f_offset = off;
452: u.u_r.r_val1 = Ltol(off);
453: u.u_r.r_val2 = off.hi;
454: }
455:
456:
457: /*
458: * link system call
459: */
460: link()
461: {
462: register struct inode *ip;
463: register struct a {
464: char *target;
465: char *linkname;
466: } *uap;
467: struct argnamei nmarg;
468:
469: uap = (struct a *)u.u_ap;
470: ip = namei(uap->target, SEGUDATA, &nilargnamei, 0); /* well, this routine is doomed anyhow */
471: if(ip == NULL)
472: return;
473: if((ip->i_mode&IFMT)==IFDIR && !suser())
474: goto out1;
475: ip->i_nlink++;
476: ip->i_flag |= ICHG;
477: iupdat(ip, &time, &time, 1);
478: prele(ip);
479: nmarg = nilargnamei;
480: nmarg.flag = NI_LINK;
481: nmarg.un.il = ip;
482: (void) namei(uap->linkname, SEGUDATA, &nmarg, 0);
483: if(u.u_error) {
484: ip->i_nlink--;
485: ip->i_flag |= ICHG;
486: }
487: out1:
488: iput(ip);
489: }
490:
491: /*
492: * mknod system call
493: */
494: mknod()
495: {
496: register struct inode *ip;
497: register struct a {
498: char *fname;
499: int fmode;
500: int dev;
501: } *uap;
502: struct argnamei nmarg;
503:
504: uap = (struct a *)u.u_ap;
505: if(suser()) {
506: nmarg = nilargnamei;
507: nmarg.flag = NI_NXCREAT;
508: nmarg.un.mode = uap->fmode & ~u.u_cmask;
509: ip = namei(uap->fname, SEGUDATA, &nmarg, 0);
510: }
511: if(u.u_error)
512: return;
513: if (uap->dev) {
514: /*
515: * Want to be able to use this to make badblock
516: * inodes, so don't truncate the dev number.
517: */
518: ip->i_un.i_rdev = uap->dev;
519: ip->i_flag |= IACC|IUPD|ICHG;
520: }
521: iput(ip);
522: }
523:
524: /*
525: * access system call
526: */
527: saccess()
528: {
529: register svuid, svgid;
530: register struct inode *ip;
531: register struct a {
532: char *fname;
533: int fmode;
534: } *uap;
535:
536: uap = (struct a *)u.u_ap;
537: svuid = u.u_uid;
538: svgid = u.u_gid;
539: u.u_uid = u.u_ruid;
540: u.u_gid = u.u_rgid;
541: ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1);
542: if (ip != NULL) {
543: if (uap->fmode&(IREAD>>6))
544: (void) access(ip, IREAD);
545: if (uap->fmode&(IWRITE>>6))
546: (void) access(ip, IWRITE);
547: if (uap->fmode&(IEXEC>>6))
548: (void) access(ip, IEXEC);
549: iput(ip);
550: }
551: u.u_uid = svuid;
552: u.u_gid = svgid;
553: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.