![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fifo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to fifo.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* $Header: /src386/STREAMS/coh.386/RCS/fifo.c,v 2.3 93/08/09 13:35:27 bin Exp Locker: bin $ */
2: /*
3: * File: fifo.c
4: *
5: * Purpose: allow kernel to fetch data from real-mode bootstrap data area
6: *
7: * $Log: fifo.c,v $
8: * Revision 2.3 93/08/09 13:35:27 bin
9: * Kernel 82 changes
10: *
11: * Revision 2.3 93/07/26 14:59:42 nigel
12: * Nigel's R80
13: *
14: * Revision 1.3 93/04/14 10:06:27 root
15: * r75
16: *
17: * Revision 1.2 92/01/06 11:59:11 hal
18: * Compile with cc.mwc.
19: */
20:
21: /*
22: * Includes.
23: */
24:
25: #include <kernel/typed.h>
26:
27: /*
28: * Definitions.
29: * Constants.
30: * Macros with argument lists.
31: * Typedefs.
32: * Enums.
33: */
34:
35: typedef unsigned char uchar;
36: typedef unsigned int uint;
37: typedef unsigned long ulong;
38:
39: /*
40: * Functions.
41: * Import Functions.
42: * Export Functions.
43: * Local Functions.
44: */
45: FIFO * fifo_open();
46: int fifo_close();
47: typed_space * fifo_read();
48:
49: /*
50: * Global Data.
51: * Import Variables.
52: * Export Variables.
53: * Local Variables.
54: *
55: * Arguments are passed into the kernel through boot_gift.
56: * If you start getting "Not enough room for all arguments." messages
57: * at boot time, just increase the BG_LEN to whatever you need.
58: * This structure is EXACTLY BG_LEN bytes long.
59: */
60: TYPED_SPACE(boot_gift, BG_LEN, T_FIFO_SIC);
61:
62: /*
63: * fifo_open()
64: *
65: * Open a typed space as a fifo.
66: *
67: * Takes a typed_space that is already allocated, and a mode. The type of
68: * the typed space must be a FIFO. Only T_FIFO_SIC has been implemented
69: * (static, in-core fifo).
70: *
71: * The mode indicates whether to open for reading or writing.
72: * mode == 0 means read only.
73: * mode == 1 means write only.
74: * Other values are illegal.
75: *
76: * Returns a pointer to an initialized FIFO structure. FIFO structures are
77: * allocated from a pre-allocated array. Returns F_NULL if it can't open
78: * the fifo.
79: */
80: FIFO *
81: fifo_open(fifo_space, mode)
82: typed_space *fifo_space;
83: int mode;
84: {
85: /* ff_table is a table of FIFO structures which can be allocated on
86: * demand. It is functionally similiar to the file descriptor table
87: * in the kernel.
88: */
89: static FIFO ff_table[NFIFOS];
90: static int inited = 0; /* Has ff_table been initialized? */
91:
92: int i; /* A handy counter. */
93: FIFO *the_fifo; /* The fifo we are going to allocate. */
94:
95: /* Initialize ff_table the first time we get called. */
96: if (!inited) {
97: for (i = 0; i < NFIFOS; ++i) {
98: ff_table[i].f_space = F_NULL;
99: ff_table[i].f_flags = 0;
100: }
101: inited = 1;
102: }
103:
104: /* Check the type of the space we were passed. */
105: switch (fifo_space->ts_type) {
106: case T_FIFO: /* Overly general type, assuming SIC. */
107: fifo_space->ts_type = T_FIFO_SIC;
108: break;
109: case T_FIFO_SIC: /* Static In-core Fifo. */
110: break;
111: case T_FIFO_DIC: /* Dynamic In-core Fifo (can grow). */
112: return(F_NULL); /* Unimplemented. */
113: case T_FIFO_SP: /* Static Permanent Fifo (fixed size file). */
114: return(F_NULL); /* Unimplemented. */
115: case T_FIFO_DP: /* Dynamic Permanent Fifo (ordinary file). */
116: return(F_NULL); /* Unimplemented. */
117: default:
118: return(F_NULL); /* Illegal type encountered. */
119: }
120:
121: /* ASSERTION: fifo_space is a valid and implemented FIFO. */
122:
123: /* Find the first free FIFO structure. */
124:
125: /* This should be re-implemented using a malloc-based scheme.
126: * At the moment, the tertiary boot libraries do not include a
127: * malloc.
128: */
129: for (i = 0; (i < NFIFOS) && (0 != ff_table[i].f_flags); ++i) {
130: /* Do nothing else. */
131: }
132:
133: if (NFIFOS == i) {
134: return(F_NULL); /* No more free fifo structs. */
135: }
136:
137: the_fifo = &(ff_table[i]);
138:
139: /* ASSERTION: the_fifo points at a FIFO we can take. */
140:
141: /* Initialize the FIFO struct. */
142: the_fifo->f_space = fifo_space;
143: the_fifo->f_offset = fifo_space->ts_data;
144:
145: /* Initilize the flags. */
146: switch(mode) {
147: case 0: /* read */
148: the_fifo->f_flags |= F_READ;
149: break;
150: case 1: /* write */
151: the_fifo->f_flags |= F_WRITE;
152: break;
153: default:
154: return(F_NULL); /* Illegal mode flag. */
155: }
156:
157: return(the_fifo);
158: } /* fifo_open() */
159:
160: /*
161: * fifo_close()
162: *
163: * Finish with using a typed space as a fifo.
164: * Free up FIFO structure associated with a typed space.
165: * Returns 0 if ffp was not open, 1 otherwise.
166: */
167: int
168: fifo_close(ffp)
169: FIFO *ffp;
170: {
171: if (0 == ffp->f_flags) {
172: return(0); /* This ffp is not open. */
173: }
174: ffp->f_space = F_NULL;
175: ffp->f_offset = 0;
176: ffp->f_flags = 0;
177:
178: return(1);
179: } /* fifo_close() */
180:
181: /*
182: * fifo_read()
183: *
184: * Read a typed space from a fifo.
185: * Return a pointer to the next typed space in the fifo ffp. Returns
186: * NULL on end of fifo.
187: *
188: * This read assumes that ffp->f_space has type T_FIFO_SIC.
189: */
190: typed_space *
191: fifo_read(ffp)
192: register FIFO *ffp;
193: {
194: typed_space *retval;
195:
196: /* Read MUST be set. */
197: if (F_READ != F_READ & ffp->f_flags ) {
198: printf(" fifo_read: READ not set ");
199: return 0; /* This ffp is not open for reading. */
200: }
201:
202: /* From here to the end of fifo_read is really fifo_read_sic(). */
203:
204:
205: /* Space of size 0 marks EOFIFO. */
206: if ((long)0 == ffp->f_offset->ts_size) {
207: printf(" fifo_read: space of size 0 ");
208: retval = 0;
209: } else {
210: /* Return the next space. */
211: retval = ffp->f_offset;
212: /* Advance to the next space. */
213: (char *) ffp->f_offset += ffp->f_offset->ts_size;
214: }
215:
216: return retval;
217: } /* fifo_read() */
218:
219: #ifdef TEST
220: #include <stdio.h>
221:
222: /* This is the typed space we will use for our FIFO operations. */
223: TYPED_SPACE(global_space, 128, T_FIFO_SIC); /* Static In-Core Fifo. */
224:
225: void
226: main()
227: {
228: FIFO *ffp; /* Fifo pointer for a handle. */
229: char line[1024]; /* Place to put input lines. */
230: long size; /* Length for line. (Sizes are all long.) */
231: int i;
232:
233: typed_space *local_space;
234:
235: /* Open the fifo for writing. */
236: if (F_NULL == (ffp = fifo_open(&global_space, 1))) {
237: fprintf(stderr, "Can't open global_space for writing.\n");
238: exit(1);
239: }
240:
241: do {
242: printf("Feed me: ");
243: gets(line);
244: size = (long) (strlen(line) + 1);
245: } while (fifo_write_untyped(ffp, line, size, T_STR_STR));
246:
247: if (0 == fifo_close(ffp)) {
248: fprintf(stderr, "Failed to close global_space.\n");
249: exit(1);
250: }
251:
252: printf("OK, global_space is now full.\n");
253: /* ASSERTION: We've filled global_space with strings. */
254:
255: /* Open the fifo for reading. */
256: if (F_NULL == (ffp = fifo_open(&global_space, 0))) {
257: fprintf(stderr, "Can't open global_space for reading.\n");
258: exit(1);
259: }
260:
261: /* Dump the contents of this FIFO. */
262: for (i = 1; (local_space = fifo_read(ffp)); ++i) {
263: printf("%d: size: %ld: type: 0x%x\n", i,
264: local_space->ts_size,
265: local_space->ts_type);
266:
267: /* Assume everything is a NUL terminated string. */
268: printf("datum: %s\n\n", local_space->ts_data);
269: printf("Hit <RETURN>");
270: gets(line);
271: }
272:
273:
274: /* Rewind the file, and dump it out again. */
275: printf("Rewinding.\n");
276: if (0 == fifo_rewind(ffp)) {
277: fprintf("Can't rewind global_space.\n");
278: exit(1);
279: }
280:
281: for (i = 1; (local_space = fifo_read(ffp)); ++i) {
282: printf("%d: size: %ld: type: 0x%x\n", i,
283: local_space->ts_size,
284: local_space->ts_type);
285:
286: /* Assume everything is a NUL terminated string. */
287: printf("datum: %s\n\n", local_space->ts_data);
288: }
289:
290: if (0 == fifo_close(ffp)) {
291: fprintf(stderr, "Failed to close global_space.\n");
292: exit(1);
293: }
294:
295: exit(0);
296: } /* main() */
297:
298: #endif /* TEST */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.