![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ay.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src|
Return to ay.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src |
1.1 root 1: static char Sccsid[] = "ay.c @(#)ay.c 1.1 10/1/82 Berkeley ";
2: #
3:
4: /*
5: * APL Buffered I/O routines
6: *
7: *
8: * The following routines perform all of the I/O required by APL.
9: * They are designed to maximize buffer utilization while maintaining
10: * reliable operation. For a machine such as the PDP-11, the number
11: * of buffers, defined in apl.h, should be around 4 for best results.
12: * For a machine such as the VAX 11/780, a larger number may be desirable
13: * for better results.
14: *
15: */
16:
17: #include "apl.h" /* Header definitions */
18: #ifdef NBUF /* Don't do any of this unless buffering
19: * was requested by defining NBUF
20: */
21:
22: #define realfd(x) files[x].fd_dup
23:
24: openf(fname, mode)
25: char *fname;
26: {
27:
28: int fd;
29:
30:
31: /* The first order of business is to open the
32: * file. If this fails, return -1.
33: */
34:
35: if ((fd=open(fname,mode)) < 0) return(fd);
36:
37:
38: /* Now, perform all of the work necessary for setting
39: * up the file tables. This code is shared by "openf"
40: * and "creatf" since both open files.
41: */
42:
43: openup(fd);
44: return(fd);
45: }
46:
47: creatf(fname, mode)
48: char *fname;
49: {
50:
51: int fd;
52:
53:
54: /* The first order of business is to create the
55: * file. If this fails, return -1.
56: */
57:
58: if ((fd=creat(fname,mode)) < 0) return(fd);
59:
60:
61: /* Now, perform all of the work necessary for setting
62: * up the file tables. This code is shared by "openf"
63: * and "creatf" since both open files.
64: */
65:
66: openup(fd);
67: return(fd);
68: }
69:
70: openup(fd)
71: {
72: struct stat stat_buf;
73: register struct fds *p, *q;
74: register j;
75:
76:
77: /* Try to perform an "fstat" call on the file. This
78: * information is required for all file descriptors
79: * to prevent reading from a file while data destined
80: * for that file is still buffered for output. If for
81: * some reason the "fstat" fails, arbitrarily set
82: * the major/minor number and inode number to zero.
83: */
84:
85: if (fstat(fd, &stat_buf) < 0){
86: write(2, "Can't \"stat\" new fd\n", 20);
87: stat_buf.st_dev = 0;
88: stat_buf.st_ino = 0;
89: }
90:
91:
92: /* Copy the information into the "files" structure, which
93: * maintains such data on all open files.
94: */
95:
96: p = &files[fd];
97: p->fd_dev = stat_buf.st_dev; /* Major/minor device numbers */
98: p->fd_ind = stat_buf.st_ino; /* Inode number */
99: p->fd_open = 1; /* File is open */
100: p->fd_buf = -1; /* No buffer is currently assigned */
101: p->fd_dup = fd; /* All it duplicates is itself */
102: p->fd_lastop = 0; /* Lastop was read (default) */
103: p->fd_pipe = !!lseek(fd, 0L, 1); /* Seek will fail if a pipe */
104:
105:
106: /* Determine if the new fd is unique or not. If not,
107: * make sure any matching fd's know that they no longer
108: * are either.
109: */
110:
111: p->fd_uniq = 1; /* Assume uniqueness */
112: for(j=0; j<NFDS; j++){
113: if (!files[j].fd_open) continue; /* File not open */
114:
115: q = &files[realfd(j)];
116: if (p->fd_ind == q->fd_ind && p->fd_dev == q->fd_dev)
117: p->fd_uniq = q->fd_uniq = 0;
118: }
119: check(); /*DEBUG*/
120: }
121:
122: dupf(fd)
123: {
124:
125: int fd2;
126: register struct fds *p, *q;
127:
128:
129: /* Duplicating a file descriptor does not require an "fstat"
130: * on the new file descriptor, because its device and inode
131: * are already recorded. However, duplicate file descriptors
132: * complicate I/O because they MUST be linked to the same
133: * buffer.
134: */
135:
136: if ((fd2=dup(fd)) < 0) return(fd2); /* Get new fd */
137:
138: /* Copy all of the information into the "files" for the new
139: * file descriptor. The uniqueness of the original fd is copied
140: * to the new fd -- they both represent the same thing.
141: */
142:
143: p = &files[fd]; /* Point to appropriate places */
144: q = &files[fd2];
145:
146: q->fd_dev = p->fd_dev; /* Major/minor device number */
147: q->fd_ind = p->fd_ind; /* Inode number */
148: q->fd_buf = -1; /* Buffer is assigned to princ. fd */
149: q->fd_uniq = p->fd_uniq; /* Uniqueness of dev/inode */
150: q->fd_dup = p->fd_dup; /* Point new entry to old one */
151: q->fd_open = 1; /* File is now open */
152: q->fd_lastop = p->fd_lastop; /* Last operation is the same */
153:
154: return(fd2); /* Return new fd */
155: }
156:
157: closef(fd)
158: {
159:
160: register j;
161: register struct fds *p, *q;
162: int fd2, count;
163:
164: /* Closing a file is easier than opening it, but some precautions
165: * are necessary. For instance, if a "dup" was performed to
166: * obtain some new file descriptor and the original file is
167: * now being closed, the duplicated file must retain all
168: * pertinent information. Thus, the first order of business
169: * is to scan the list of file descriptors for duplicates.
170: */
171:
172: p = &files[fd]; /* Entry for dying fd */
173:
174: count = 0; /* Number of remaining dups */
175: fd2 = -1; /* New fd reference for dups */
176:
177: if (p->fd_dup == fd) for (j=0; j<NFDS; j++){
178: if (j == fd) continue; /* Don't look at fd */
179: q = &files[j];
180: if (!q->fd_open) continue; /* Not open */
181: if (q->fd_dup != fd) continue;
182: if (fd2 == -1){
183: fd2 = j; /* New reference */
184: q->fd_buf = p->fd_buf; /* Vital data */
185: q->fd_open = 1;
186: q->fd_lastop = p->fd_lastop;
187: }
188: q->fd_dup = fd2;
189: count++;
190: }
191:
192:
193: /* Flush and release the buffer associated with this fd. */
194:
195: newbuf(files[realfd(fd)].fd_buf, -1);
196:
197:
198: /* Mark the entry in the file descriptor table as "closed"
199: * and check the uniqueness of any remaining fd's pointing to
200: * the same area. Be sure the buffer is released.
201: */
202:
203: p->fd_open = 0;
204: p->fd_dup = fd;
205: p->fd_buf = -1;
206:
207: for(j=0; j<NFDS; j++){
208: if (j == fd) continue; /* Skip the same fd */
209: q = &files[fd];
210: if (!q->fd_open) continue; /* Skip closed files */
211: if (p->fd_dev == q->fd_dev && p->fd_ind == q->fd_ind) break;
212: }
213:
214: if (j<NFDS) q->fd_uniq = 1; /* Assume new fd is unique */
215: while(++j < NFDS){ /* Now check to be sure */
216: p = &files[j];
217: if (p->fd_dev == q->fd_dev && p->fd_ind == q->fd_ind)
218: p->fd_uniq = q->fd_uniq = 0;
219: }
220:
221:
222: /* Actually perform the close of the fd, and return the status
223: * of that system call.
224: */
225:
226: return(close(fd));
227: }
228:
229:
230: initbuf()
231: {
232:
233: /* Initialize buffer structure, then use "openup" to set up
234: * file descriptors 0, and 1, which should already be
235: * open from parent process. If 0 and 1 have the same inode
236: * and major/minor number they will be considered to be
237: * duplicates. Fils descriptor 2 will be closed and set to
238: * duplicate file descriptor 1.
239: */
240:
241: register j;
242: register struct fds *p, *q;
243:
244:
245: /* Initialize file descriptor table */
246:
247: for(j=0; j<NFDS; j++){
248: files[j].fd_open = 0; /* Closed */
249: files[j].fd_dup = j; /* Dup = fd */
250: files[j].fd_buf = -1; /* No buffer */
251: files[j].fd_pipe = 0; /* Not pipe */
252: }
253:
254:
255: /* Initialize buffer table */
256:
257: for(j=0; j<NBUF; j++) iobuf[j].b_fd = -1; /* Available */
258:
259:
260: /* "Open" devices 0, and 1 */
261:
262: openup(0);
263: openup(1);
264: p = &files[0];
265: q = &files[1];
266: if (p->fd_ind == q->fd_ind && p->fd_dev == q->fd_dev){
267: q->fd_dup = 0;
268: p->fd_uniq = q->fd_uniq = 1;
269: }
270:
271:
272: /* File descriptor 2 duplicates fd 1 */
273:
274: close(2);
275: dupf(1);
276: }
277:
278: newbuf(bufnum, fd)
279: {
280:
281: register struct iobuf *bp;
282: register struct fds *fp;
283: register j;
284: static int bufcnt = 0;
285:
286:
287: /* The two arguments for this routine specify a buffer to
288: * be operated upon and a file descriptor. There are three
289: * legal cases:
290: *
291: * bufnum < 0, fd >= 0 -- assign new buffer to file descriptor fd
292: * bufnum >= 0, fd >= 0 -- assign buffer "bufnum" to fd
293: * bufnum >= 0, fd < 0 -- de-assign buffer "bufnum"
294: */
295:
296: if ((bufnum < 0 && fd < 0) || bufnum >= NBUF || fd >= NFDS)
297: return(-1); /* Invalid args */
298:
299: fd = (fd < 0) ? fd : realfd(fd); /* Handle dups */
300:
301:
302: /* Step one -- if a buffer was specified, flush it. If the
303: * last operation was a write, then write out the rest of
304: * the buffer. If the last operation was a read, then perform
305: * a seek backwards on the corresponding fd to reposition the
306: * next read.
307: */
308:
309: if (bufnum >= 0){
310: bp = &iobuf[bufnum];
311: if (bp->b_len && (bp->b_fd >= 0))
312: if (files[bp->b_fd].fd_lastop)
313: write(bp->b_fd, bp->b_buf, bp->b_len);
314: else
315: lseek(bp->b_fd, (long)-bp->b_len, 1);
316:
317: bp->b_len = 0; /* Reset length */
318: bp->b_next = 0; /* Reset next position */
319:
320:
321: /* Step one point five -- if a file descriptor was
322: * specified, check to insure that it is open. Then,
323: * reassign the buffer to that fd.
324: */
325:
326: if(bp->b_fd >= 0) /* Drop old assignment */
327: files[bp->b_fd].fd_buf = -1;
328:
329: bp->b_fd = fd; /* Give buffer new fd */
330: if (fd < 0) return(0); /* If fd < 0, done */
331:
332: fp = &files[fd]; /* Point to new structure */
333:
334: if (!fp->fd_open){ /* New file is not open */
335: bp->b_fd = -1; /* Drop assignment */
336: return(-1);
337: }
338:
339: fp->fd_buf = bufnum; /* New assignment */
340: return(0);
341:
342: }
343:
344:
345: /* Step two -- if no buffer was specified, but a file descriptor
346: * was, then some existing buffer must be allocated to that fd.
347: */
348:
349: fp = &files[fd];
350:
351:
352: /* First, check to see if a buffer is already assigned */
353:
354: for (j=0; j<NBUF; j++)
355: if (iobuf[j].b_fd == fd){
356: bufcnt = j;
357: goto recursive;
358: }
359:
360:
361: /* Next, scan the table of buffers looking for one
362: * which is not assigned.
363: */
364:
365: for (j=0; j<NBUF; j++) if (iobuf[j].b_fd < 0){
366: bufcnt = j;
367: goto recursive;
368: }
369:
370:
371: /* If no vacant buffer was found, then a buffer must
372: * be allocated arbitrarily. The static local variable
373: * "bufcnt" is used for this purpose. It contains the
374: * number of the last assigned buffer. Buffers are
375: * switched in a sort-of "round robin" approach.
376: */
377:
378: j = bufcnt;
379: do {
380: bp = &iobuf[j];
381: fp = &files[bp->b_fd];
382: if (fp->fd_pipe && (!fp->fd_lastop) && bp->b_len > 0)
383: continue;
384: bufcnt = j;
385: goto recursive;
386: } while((j = (j+1)%NBUF) != bufcnt);
387: return(-1);
388:
389:
390: /* Now, with a recursive call to this routine,
391: * switch to the new buffer.
392: */
393:
394: recursive: return(newbuf(bufcnt, fd));
395:
396: }
397:
398: #ifndef realfd
399: realfd(fd)
400: {
401:
402: register struct fds *fp;
403:
404:
405: /* Process duplicate file descriptors. If the main fd is
406: * nonnegative, use the value of the dup number for the true fd.
407: * No change is made if the file is closed.
408: */
409:
410: fp = &files[fd];
411: if (!fp->fd_open) return(fd);
412: return(fp->fd_dup < 0 ? fd : fp->fd_dup);
413: }
414: #endif
415:
416:
417: readf(fd, buffer, length)
418: char *buffer;
419: {
420:
421: register struct fds *fp;
422: register struct iobuf *bp;
423: register j;
424: int change, trlog, again;
425:
426:
427: /* Handle duplicate files first. If this file descriptor is
428: * a duplicate of another one, then the other's buffer and
429: * other information must be used.
430: */
431:
432: fd = realfd(fd);
433:
434:
435: /* If a read is to be performed on a file, all output to that
436: * file must first be flushed. If the file descriptor's last
437: * function was output, use "newbuf" to flush the output,
438: * retaining the buffer, and then set the mode to input. This
439: * must be done for all entries in "files" which have the same
440: * major/minor number as the current file.
441: */
442:
443:
444:
445: fp = &files[fd];
446: if (!fp->fd_open) return(-1); /* File not open */
447: if (fp->fd_uniq){
448: if (fp->fd_lastop && fp->fd_buf >= 0)
449: newbuf(fp->fd_buf, fd);
450: } else for(j=0; j<NFDS; j++){
451: fp = &files[realfd(j)];
452: if (fp->fd_dev == files[fd].fd_dev
453: && fp->fd_ind == files[fd].fd_ind
454: && fp->fd_open
455: && fp->fd_lastop
456: && fp->fd_buf >= 0){
457: newbuf(fp->fd_buf, j);
458: }
459: }
460:
461:
462: /* The above code nicely took care of any buffer associated
463: * with the current fd. Now, set the last operation on this fd
464: * to read, and if no buffer is currently assigned, get one.
465: */
466:
467: fp = &files[fd];
468: fp->fd_lastop = 0;
469:
470: if (fp->fd_buf < 0)
471: if (newbuf(-1, fd) < 0) return(read(fd, buffer, length));
472:
473:
474: /* The flag "again" determines whether or not the read buffer
475: * should be refilled when the end of it is reached. Basically,
476: * "again" is set to 0 when a read of less than one buffer length
477: * occurs. This way, terminal reads can stop at the carriage
478: * return, but disc reads can still buffer in BLEN-byte chunks
479: */
480:
481: again = 1;
482:
483:
484: /* The variable "trlog" keeps track of how many bytes have been
485: * transferred into the buffer supplied by the routine which
486: * called "readf". Initially, this number is -1 (EOF).
487: */
488:
489: trlog = -1;
490:
491:
492: /* The main loop is rather simple -- the buffer is continually
493: * emptied and refilled until all of the requested data has been
494: * transferred.
495: */
496:
497: bp = &iobuf[fp->fd_buf];
498: while(1){
499: if (length <= 0) return(trlog);
500: if (bp->b_len == 0 && again){
501: again = (bp->b_len=read(fd,bp->b_buf,BLEN)) == BLEN;
502: bp->b_next = 0;
503: }
504: if (bp->b_len <= 0) return(trlog);
505: if (trlog < 0) trlog++;
506: change = (bp->b_len < length) ? bp->b_len : length;
507: for (j=0; j<change; j++)
508: buffer[trlog+j] = bp->b_buf[bp->b_next+j];
509: trlog += change;
510: bp->b_len -= change;
511: bp->b_next += change;
512: length -= change;
513: }
514: }
515:
516:
517: writef(fd, buffer, length)
518: char *buffer;
519: {
520:
521: register struct fds *fp;
522: register struct iobuf *bp;
523: register j;
524: int change, trlog, again;
525:
526:
527: /* Handle duplicate files first. If this file descriptor is
528: * a duplicate of another one, then the other's buffer and
529: * other information must be used.
530: */
531:
532: fd = realfd(fd);
533:
534:
535: /* If a write is to be performed on a file, all input from that
536: * file must first be flushed. If the file descriptor's last
537: * function was input, use "newbuf" to flush the input,
538: * retaining the buffer, and then set the mode to output. This
539: * must be done for all entries in "files" which have the same
540: * major/minor number as the current file.
541: */
542:
543: fp = &files[fd];
544: if (!fp->fd_open) return(-1); /* File not open */
545: if (fp->fd_uniq){
546: if ((!fp->fd_lastop) && fp->fd_buf >= 0)
547: newbuf(fp->fd_buf, fd);
548:
549: } else for(j=0; j<NFDS; j++){
550: fp = &files[realfd(j)];
551: if (fp->fd_dev == files[fd].fd_dev
552: && fp->fd_ind == files[fd].fd_ind
553: && fp->fd_open
554: && (!fp->fd_lastop)
555: && fp->fd_buf >= 0){
556: newbuf(fp->fd_buf, j);
557: }
558: }
559:
560:
561: /* The above code nicely took care of any buffer associated
562: * with the current fd. Now, set the last operation on this fd
563: * to write, and if no buffer is currently assigned, get one.
564: */
565:
566: fp = &files[fd];
567: fp->fd_lastop = 1;
568:
569: if (fp->fd_buf < 0)
570: if (newbuf(-1, fd) < 0) return(write(fd,buffer,length));
571:
572:
573: /* The main loop of output, like the main loop for input, is
574: * rather simple. In fact, output is easier. It is only
575: * necessary to check when the buffer is full and to flush it
576: * as necessary to the file.
577: */
578:
579: bp = &iobuf[fp->fd_buf];
580: trlog = 0;
581: while(1){
582: if (!length) return(trlog);
583: if (bp->b_len >= BLEN){
584: write(fd, bp->b_buf, bp->b_len);
585: bp->b_next = bp->b_len = 0;
586: }
587:
588: change = ((BLEN - bp->b_len) < length) ?
589: (BLEN - bp->b_len) : length;
590:
591: for (j=0; j<change; j++)
592: bp->b_buf[j+bp->b_next] = buffer[j+trlog];
593:
594: trlog += change;
595: bp->b_next = bp->b_len += change;
596: length -= change;
597: }
598: }
599:
600: long lseekf(fd, p1, p2)
601: int fd, p2;
602: long p1;
603: {
604:
605: register struct fds *fp;
606: register j;
607: long lseek();
608:
609:
610: /* A seek on a file requires a flush of the buffer for that
611: * file and for any other file descriptors which are pointing
612: * to the same file.
613: */
614:
615: fd = realfd(fd); /* Take care of dups */
616: fp = &files[fd];
617:
618: if (!fp->fd_open) return(-1); /* not open */
619:
620: if (fp->fd_uniq){
621: if (fp->fd_buf >= 0) newbuf(fp->fd_buf, fd);
622: } else for(j=0; j<NFDS; j++){
623: fp = &files[j];
624: if (fp->fd_dev == files[fd].fd_dev
625: && fp->fd_ind == files[fd].fd_ind
626: && fp->fd_open
627: && fp->fd_buf >= 0)
628: newbuf(fp->fd_buf, j);
629: }
630:
631:
632: /* Now that all of the preliminaries are over, the actual
633: * seek can be performed.
634: */
635:
636: return(lseek(fd, p1, p2));
637: }
638:
639: fstatf(fd, stat_buf)
640: struct stat *stat_buf;
641: {
642:
643: register fd2;
644:
645: fd2 = realfd(fd);
646: newbuf(files[fd2].fd_buf, fd2);
647: return(fstat(fd, stat_buf));
648:
649: }
650:
651: bflush(){
652:
653: register j;
654:
655: /* Flush all buffers */
656:
657: for(j=0; j<NBUF; j++) newbuf(j, -1);
658: }
659:
660: check()
661: {
662: register j, k;
663:
664: for (j=0; j<NFDS; j++)
665: if ((k=files[j].fd_buf) >= 0)
666: if (iobuf[k].b_fd != j){
667: write(2, "CONSISTENCY CHECK!\n", 19);
668: if (files[j].fd_dup != j)
669: write(2, "BAD DUP ENTRY\n", 14);
670: }
671:
672:
673: for (j=0; j<NBUF; j++)
674: if ((k=iobuf[j].b_fd) >= 0)
675: if (files[k].fd_buf != j)
676: write(2, "CONSISTENCY CHECK2!\n", 20);
677:
678: }
679:
680: #endif
681:
682: empty(fd){
683:
684: struct stat sbuf;
685: register struct fds *fp;
686:
687: /* Simulate the Rand Corp.'s "empty" system call on a
688: * V7 system by seeing if the given fd is a pipe, and if
689: * so, whether or not it is empty.
690: */
691:
692: #ifdef NBUF
693: fp = &files[realfd(fd)];
694:
695: if (!fp->fd_pipe || !fp->fd_open)
696: return(-1); /* Not a pipe */
697:
698: if (fp->fd_buf >= 0 && iobuf[fp->fd_buf].b_len > 0)
699: return(0); /* Data pending in buffer */
700: #endif
701:
702: if (fstat(fd, &sbuf) < 0)
703: return(-1); /* Can't "stat" it */
704:
705: return(sbuf.st_size == 0);
706: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.