Working with the Unix OS

I/O Subsystem
algorithm terminal_read
{
if (no data on canonical clist)
{
while (no data on raw clist)
{
if (tty opened with no delay option)
return;
if (tty in raw mode based on timer and timer not active)
arrange for timer wakeup (callout table);
sleep (event: data arrives from terminal);
}
Figure 37. Algorithm
for Reading a
Terminal
}
if (tty in raw mode) /* there is data on raw clist */
copy all data from raw c1ist to canonical c1ist;
else
/* tty is in canonical mode *'
{
while (characters on raw clist)
{
copy one character at a time from raw c1ist to canonical clist:
do erase, kill processing;
if (char is carriage return or end-of-file)
break; /* out of while loop */
}
}
}
while (characters on canonical list and read count not satisfied)
copy from cblocks on canonical list to user address space;
If no data is
currently on either
input clist, the
reading process
sleeps until the
arrival of a line of
data.
When data is entered, the terminal interrupt handler invokes the line discipline interrupt handler, which places the
data on the raw clist for input to reading processes and on the output clist for echoing back to the terminal.
Character processing in input and output directions is asymmetric, two input clists and one output clist.
The use of two input clists means that the interrupt handler can simply dump characters onto the raw clist and
wakeup up reading processes, which properly incur the expense of processing input data.
The interrupt handler puts input characters immediately on the output clist, so that the user sees the typed character
with minimal delay.
char input[256];
main()
{
register int i;
for (i = 0; i < 18; i++)
{
switch (fork())
{
case -1: /* error */
printf("error cannot fork\n");
exitO;
default: /* parent process * /
break;
case 0: /* child process */
for (;;)
{
read(0, input, 256); /* read line */
printf("%d read %s\n", i, input);
}
}
}
}
149
Figure 38. Contending for Terminal Input
Data
The processes will spend most of their
time sleeping in terminal_read,
waiting for input data.
Intelligent terminals "cook" their
input in the peripheral, freeing CPU
for other work.