Seventh Edition Unix terminal interface
The Seventh Edition Unix terminal interface is the generalized abstraction, comprising both an application programming interface for programs and a set of behavioural expectations for users, of a terminal as historically available in Seventh Edition Unix. It has been largely superseded by the POSIX terminal interface.
Concepts and overview
The terminal interface provided by Seventh Edition Unix and UNIX/32V, and also presented by BSD version 4 as the old terminal driver, was a simple one, largely geared towards teletypewriters as terminals. Input was entered a line at a time, with the terminal driver in the operating system (and not the terminals themselves) providing simple line editing capabilities. A buffer was maintained by the kernel in which editing took place. Applications reading terminal input would receive the contents of the buffer only when the key was pressed on the terminal to end line editing. The key sent from the terminal to the system would erase ("kill") the entire current contents of the editing buffer, and would be normally displayed as an '@' symbol followed by a newline sequence to move the print position to a fresh blank line. The key sent from the terminal to the system would erase the last character from the end of the editing buffer, and would be normally displayed as an '#' symbol, which users would have to recognize as denoting a "rubout" of the preceding character (teletypewriters not being physically capable of erasing characters once they have been printed on the paper).[1][2][3][4][5]
From a programming point of view, a terminal device had transmit and receive baud rates, "erase" and "kill" characters (that performed line editing, as explained), "interrupt" and "quit" characters (generating signals to all of the processes for which the terminal was a controlling terminal), "start" and "stop" characters (used for software flow control), an "end of file" character (acting like a carriage return except discarded from the buffer by the read() system call and therefore potentially causing a zero-length result to be returned) and various mode flags determining whether local echo was emulated by the kernel's terminal driver, whether modem flow control was enabled, the lengths of various output delays, mapping for the carriage return character, and the three input modes.[6]
Input modes
The three input modes for terminals in Seventh Edition Unix were:
- line mode (also called "cooked" mode)
- In line mode the line discipline performs all line editing functions and recognizes the "interrupt" and "quit" control characters and transforms them into signals sent to processes. Applications programs reading from the terminal receive entire lines, after line editing has been completed by the user pressing return.[2][7]
- cbreak mode
- cbreak mode is one of two character-at-a-time modes. (Stephen R. Bourne jokingly referred to it (Bourne 1983) as a "half-cooked" and therefore "rare" mode.) The line discipline performs no line editing, and the control sequences for line editing functions are treated as normal character input. Applications programs reading from the terminal receive characters immediately, as soon as they are available in the input queue to be read. However, the "interrupt" and "quit" control characters, as well as modem flow control characters, are still handled specially and stripped from the input stream.[8][9]
- raw mode
- raw mode is the other of the two character-at-a-time modes. The line discipline performs no line editing, and the control sequences for both line editing functions and the various special characters ("interrupt", "quit", and flow control) are treated as normal character input. Applications programs reading from the terminal receive characters immediately, and receive the entire character stream unaltered, just as it came from the terminal device itself.[10][8][9]
In the POSIX terminal interface, these modes have been superseded by a system of just two input modes: canonical and non-canonical. The handling of signal-generating special characters in the POSIX terminal interface is independent of input mode, and is separately controllable.
Controlling terminals
In Seventh Edition Unix there was no terminal job control and a process group was considered to be not what it is considered to be nowadays.
Each process in the system had either a single controlling terminal, or no controlling terminal at all. A process inherits its controlling terminal from its parent. A controlling terminal was acquired when a process with no controlling terminal open()s a terminal device file that isn't already the controlling terminal for some other process. All of the processes that had the same controlling terminal were part of a single process group.[11]
Application programming interface
The programmatic interface for querying and modifying all of these modes and control characters was the ioctl() system call. (This replaced the stty() and gtty() system calls of Sixth Edition Unix.)[12][13] Although the "erase" and "kill" characters were modifiable from their defaults of and , for many years after Seventh Edition development inertia meant that they were the pre-set defaults in the terminal device drivers, and on many Unix systems, which only altered terminal device settings as part of the login process, in system login scripts that ran after the user had entered username and password, any mistakes at the login and password prompts had to be corrected using the historical editing key characters inherited from teletypewriter terminals.[4]
The symbolic constants, whose values were fixed and defined, and data structure definitions of the programmatic interface were defined in the sgtty.h system header.[8]
ioctl() operations
The ioctl() operations were as follows:
| symbol | structure pointed to by third argument | description |
|---|---|---|
TIOGETP |
sgttyb |
query terminal parameters into the data structure |
TIOSETP |
sgttyb |
set terminal parameters from the data structure, draining all pending output first and flushing queued input |
TIOSETN |
sgttyb |
set terminal parameters from the data structure, without waiting or draining |
TIOCEXCL |
none | switch on "exclusive use" mode |
TIOCNXCL |
none | switch off "exclusive use" mode |
TIOCHPCL |
none | switch on "hangup at last close" mode |
TIOCFLUSH |
none | flush all output and input queues |
TIOGETC |
tchars |
query terminal parameters into the data structure |
TIOSETC |
tchars |
set terminal parameters from the data structure |
The sgttyb data structure
One data structure used by the terminal system calls is the sgttyb structure, whose C programming language definition is as follows:[14]
struct sgttyb {
char sg_ispeed ; // Input speed
char sg_ospeed ; // Output speed
char sg_erase ; // Erase character
char sg_kill ; // Kill character
char sg_flags ; // Control flags
} ;
Unlike the POSIX terminal interface, the Seventh Edition Unix terminal interface recorded input and output baud rates directly in the data structure.[15]
The input and output speeds in the sg_ispeed and sg_ospeed fields were those of the DEC DH-11, and were the numbers 0 to 15, represented by the symbolic constants (in ascending order) B0, B50, B75, B110,B134, B150, B200, B300, B600, B1200, B1800, B2400, B4800, B9600, EXTA, and EXTB, where the baud rate was as in the name (with the last two being "external A" and "external B"). Setting a baud rate of zero forced the terminal driver to hang up a modem (if the terminal was a modem device).[14]
The sg_erase and sg_kill fields were simply the character values of the "erase" and "kill" characters, respectively, defaulting to the (ASCII) values for '#' and '@' respectively.[14]
The sg_flags field specified various input and output control flags, as in the following table.
| symbol | octal value | description |
|---|---|---|
BSDELAY |
0100000 | delay when writing BS characters |
BS0 |
0000000 | |
BS1 |
0100000 | |
VTDELAY |
0040000 | delay when writing VT and FF characters |
FF0 |
0000000 | |
FF1 |
0040000 | |
CRDELAY |
0030000 | delay when writing CR characters |
CR0 |
0000000 | |
CR1 |
0010000 | |
CR2 |
0020000 | |
CR3 |
0030000 | |
TBDELAY |
0006000 | delay when writing TAB charactersXTABS does not, technically, specify a delay, but rather causes tab characters to be converted to sequences of one or more space characters.
|
TAB0 |
0000000 | |
TAB1 |
00002000 | |
TAB2 |
0004000 | |
XTABS |
0006000 | |
NLDELAY |
0001400 | delay when writing LF characters |
NL0 |
0000000 | |
NL1 |
00000400 | |
NL2 |
0001000 | |
NL3 |
0001400 | |
EVENP |
0000200 | even parity |
ODDP |
0000100 | odd parity |
RAW |
0000040 | "raw" mode |
CRMOD |
0000020 | carriage return mapping mode (CR maps to LF on input and both CR and LF are turned into CR+LF on output) |
ECHO |
0000010 | local echo emulation by the terminal driver |
LCASE |
0000004 | map uppercase to lower case on input |
CBREAK |
0000002 | "cbreak" mode |
TANDEM |
0000001 | enable modem flow control |
The tchars data structure
One data structure used by the terminal system calls is the tchars structure, whose C programming language definition is as follows:[16]
struct tchars {
char t_intrc ; // Interrupt
char t_quitc ; // Quit
char t_startc ; // Start
char t_stopc ; // Stop
char t_eofc ; // End of File
char t_brkc ; // Break (alternative to hardwired LF character with same effect)
} ;
The values of these fields were the values of the various programmatically configurable special characters. A -1 value in any field disabled its recognition by the terminal driver.[16]
References
- ↑ Bourne 1983, p. 8.
- ↑ 2.0 2.1 Bourne 1983, p. 130–131.
- ↑ 3.0 3.1 Bourne 1983, p. 287.
- ↑ 4.0 4.1 Christian 1988, p. 26.
- ↑ Leffler et al. 1989, p. 262.
- ↑ Bourne 1983, p. 132–133.
- ↑ Leffler et al. 1989, p. 259–260.
- ↑ 8.0 8.1 8.2 Bourne 1983, p. 288.
- ↑ 9.0 9.1 Leffler et al. 1989, p. 260.
- ↑ Bourne 1983, p. 132.
- ↑ Bourne 1983, p. 130.
- ↑ Bourne 1983, p. 133.
- ↑ Christian 1988, p. 393.
- ↑ 14.0 14.1 14.2 Bourne 1983, p. 286.
- ↑ Zlotnick 1991, p. 166.
- ↑ 16.0 16.1 Bourne 1983, p. 289.
Bibliography
- Bourne, Stephen R. (1983). The UNIX system. International computer science series. Addison-Wesley. ISBN 978-0-201-13791-0.
- Christian, Kaare (1988). The UNIX Operating System (2nd ed.). John Wiley & Sons. ISBN 978-0-471-84781-6. https://archive.org/details/unixoperatingsys0000chri.
- Leffler, Samuel J.; McKusick, Marshall Kirk; Karels, Michael J.; Quarterman, John S. (1989). "Terminal Handling". The Design and implementation of the 4.3BSD UNIX operating system. Addison-Wesley series in computer science. Addison-Wesley. ISBN 978-0-201-06196-3. https://archive.org/details/designimplementa0000unse.
- Zlotnick, Fred (1991). "Controlling Terminal Devices". The POSIX.1 standard: a programmer's guide. Benjamin/Cummings Pub. Co.. ISBN 978-0-8053-9605-8. https://archive.org/details/posix1standardpr0000zlot.
 |  |
