485 lines
12 KiB
C
485 lines
12 KiB
C
/*
|
|
* linux/kernel/tty_io.c
|
|
*
|
|
* (C) 1991 Linus Torvalds
|
|
*/
|
|
|
|
/*
|
|
* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
|
|
* or rs-channels. It also implements echoing, cooked mode etc.
|
|
*
|
|
* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <unistd.h>
|
|
|
|
#define ALRMMASK (1<<(SIGALRM-1))
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/tty.h>
|
|
#include <asm/segment.h>
|
|
#include <asm/system.h>
|
|
|
|
int kill_pg(int pgrp, int sig, int priv);
|
|
int is_orphaned_pgrp(int pgrp);
|
|
|
|
#define _L_FLAG(tty,f) ((tty)->termios.c_lflag & f)
|
|
#define _I_FLAG(tty,f) ((tty)->termios.c_iflag & f)
|
|
#define _O_FLAG(tty,f) ((tty)->termios.c_oflag & f)
|
|
|
|
#define L_CANON(tty) _L_FLAG((tty),ICANON)
|
|
#define L_ISIG(tty) _L_FLAG((tty),ISIG)
|
|
#define L_ECHO(tty) _L_FLAG((tty),ECHO)
|
|
#define L_ECHOE(tty) _L_FLAG((tty),ECHOE)
|
|
#define L_ECHOK(tty) _L_FLAG((tty),ECHOK)
|
|
#define L_ECHOCTL(tty) _L_FLAG((tty),ECHOCTL)
|
|
#define L_ECHOKE(tty) _L_FLAG((tty),ECHOKE)
|
|
#define L_TOSTOP(tty) _L_FLAG((tty),TOSTOP)
|
|
|
|
#define I_UCLC(tty) _I_FLAG((tty),IUCLC)
|
|
#define I_NLCR(tty) _I_FLAG((tty),INLCR)
|
|
#define I_CRNL(tty) _I_FLAG((tty),ICRNL)
|
|
#define I_NOCR(tty) _I_FLAG((tty),IGNCR)
|
|
#define I_IXON(tty) _I_FLAG((tty),IXON)
|
|
|
|
#define O_POST(tty) _O_FLAG((tty),OPOST)
|
|
#define O_NLCR(tty) _O_FLAG((tty),ONLCR)
|
|
#define O_CRNL(tty) _O_FLAG((tty),OCRNL)
|
|
#define O_NLRET(tty) _O_FLAG((tty),ONLRET)
|
|
#define O_LCUC(tty) _O_FLAG((tty),OLCUC)
|
|
|
|
#define C_SPEED(tty) ((tty)->termios.c_cflag & CBAUD)
|
|
#define C_HUP(tty) (C_SPEED((tty)) == B0)
|
|
|
|
#ifndef MIN
|
|
#define MIN(a,b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
|
|
#define QUEUES (3*(MAX_CONSOLES+NR_SERIALS+2*NR_PTYS))
|
|
static struct tty_queue tty_queues[QUEUES];
|
|
struct tty_struct tty_table[256];
|
|
|
|
#define con_queues tty_queues
|
|
#define rs_queues ((3*MAX_CONSOLES) + tty_queues)
|
|
#define mpty_queues ((3*(MAX_CONSOLES+NR_SERIALS)) + tty_queues)
|
|
#define spty_queues ((3*(MAX_CONSOLES+NR_SERIALS+NR_PTYS)) + tty_queues)
|
|
|
|
#define con_table tty_table
|
|
#define rs_table (64+tty_table)
|
|
#define mpty_table (128+tty_table)
|
|
#define spty_table (192+tty_table)
|
|
|
|
int fg_console = 0;
|
|
|
|
/*
|
|
* these are the tables used by the machine code handlers.
|
|
* you can implement virtual consoles.
|
|
*/
|
|
struct tty_queue * table_list[]={
|
|
con_queues + 0, con_queues + 1,
|
|
rs_queues + 0, rs_queues + 1,
|
|
rs_queues + 3, rs_queues + 4
|
|
};
|
|
|
|
void change_console(unsigned int new_console)
|
|
{
|
|
if (new_console == fg_console || new_console >= NR_CONSOLES)
|
|
return;
|
|
fg_console = new_console;
|
|
table_list[0] = con_queues + 0 + fg_console*3;
|
|
table_list[1] = con_queues + 1 + fg_console*3;
|
|
update_screen();
|
|
}
|
|
|
|
static void sleep_if_empty(struct tty_queue * queue)
|
|
{
|
|
cli();
|
|
while (!(current->signal & ~current->blocked) && EMPTY(queue))
|
|
interruptible_sleep_on(&queue->proc_list);
|
|
sti();
|
|
}
|
|
|
|
static void sleep_if_full(struct tty_queue * queue)
|
|
{
|
|
if (!FULL(queue))
|
|
return;
|
|
cli();
|
|
while (!(current->signal & ~current->blocked) && LEFT(queue)<128)
|
|
interruptible_sleep_on(&queue->proc_list);
|
|
sti();
|
|
}
|
|
|
|
void wait_for_keypress(void)
|
|
{
|
|
sleep_if_empty(tty_table[fg_console].secondary);
|
|
}
|
|
|
|
void copy_to_cooked(struct tty_struct * tty)
|
|
{
|
|
signed char c;
|
|
|
|
if (!(tty->read_q || tty->write_q || tty->secondary)) {
|
|
printk("copy_to_cooked: missing queues\n\r");
|
|
return;
|
|
}
|
|
while (1) {
|
|
if (EMPTY(tty->read_q))
|
|
break;
|
|
if (FULL(tty->secondary))
|
|
break;
|
|
GETCH(tty->read_q,c);
|
|
if (c==13) {
|
|
if (I_CRNL(tty))
|
|
c=10;
|
|
else if (I_NOCR(tty))
|
|
continue;
|
|
} else if (c==10 && I_NLCR(tty))
|
|
c=13;
|
|
if (I_UCLC(tty))
|
|
c=tolower(c);
|
|
if (L_CANON(tty)) {
|
|
if ((KILL_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==KILL_CHAR(tty))) {
|
|
/* deal with killing the input line */
|
|
while(!(EMPTY(tty->secondary) ||
|
|
(c=LAST(tty->secondary))==10 ||
|
|
((EOF_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==EOF_CHAR(tty))))) {
|
|
if (L_ECHO(tty)) {
|
|
if (c<32)
|
|
PUTCH(127,tty->write_q);
|
|
PUTCH(127,tty->write_q);
|
|
tty->write(tty);
|
|
}
|
|
DEC(tty->secondary->head);
|
|
}
|
|
continue;
|
|
}
|
|
if ((ERASE_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==ERASE_CHAR(tty))) {
|
|
if (EMPTY(tty->secondary) ||
|
|
(c=LAST(tty->secondary))==10 ||
|
|
((EOF_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==EOF_CHAR(tty))))
|
|
continue;
|
|
if (L_ECHO(tty)) {
|
|
if (c<32)
|
|
PUTCH(127,tty->write_q);
|
|
PUTCH(127,tty->write_q);
|
|
tty->write(tty);
|
|
}
|
|
DEC(tty->secondary->head);
|
|
continue;
|
|
}
|
|
}
|
|
if (I_IXON(tty)) {
|
|
if ((STOP_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==STOP_CHAR(tty))) {
|
|
tty->stopped=1;
|
|
tty->write(tty);
|
|
continue;
|
|
}
|
|
if ((START_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==START_CHAR(tty))) {
|
|
tty->stopped=0;
|
|
tty->write(tty);
|
|
continue;
|
|
}
|
|
}
|
|
if (L_ISIG(tty)) {
|
|
if ((INTR_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==INTR_CHAR(tty))) {
|
|
kill_pg(tty->pgrp, SIGINT, 1);
|
|
continue;
|
|
}
|
|
if ((QUIT_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==QUIT_CHAR(tty))) {
|
|
kill_pg(tty->pgrp, SIGQUIT, 1);
|
|
continue;
|
|
}
|
|
if ((SUSPEND_CHAR(tty) != _POSIX_VDISABLE) &&
|
|
(c==SUSPEND_CHAR(tty))) {
|
|
if (!is_orphaned_pgrp(tty->pgrp))
|
|
kill_pg(tty->pgrp, SIGTSTP, 1);
|
|
continue;
|
|
}
|
|
}
|
|
if (c==10 || (EOF_CHAR(tty) != _POSIX_VDISABLE &&
|
|
c==EOF_CHAR(tty)))
|
|
tty->secondary->data++;
|
|
if (L_ECHO(tty)) {
|
|
if (c==10) {
|
|
PUTCH(10,tty->write_q);
|
|
PUTCH(13,tty->write_q);
|
|
} else if (c<32) {
|
|
if (L_ECHOCTL(tty)) {
|
|
PUTCH('^',tty->write_q);
|
|
PUTCH(c+64,tty->write_q);
|
|
}
|
|
} else
|
|
PUTCH(c,tty->write_q);
|
|
tty->write(tty);
|
|
}
|
|
PUTCH(c,tty->secondary);
|
|
}
|
|
wake_up(&tty->secondary->proc_list);
|
|
}
|
|
|
|
/*
|
|
* Called when we need to send a SIGTTIN or SIGTTOU to our process
|
|
* group
|
|
*
|
|
* We only request that a system call be restarted if there was if the
|
|
* default signal handler is being used. The reason for this is that if
|
|
* a job is catching SIGTTIN or SIGTTOU, the signal handler may not want
|
|
* the system call to be restarted blindly. If there is no way to reset the
|
|
* terminal pgrp back to the current pgrp (perhaps because the controlling
|
|
* tty has been released on logout), we don't want to be in an infinite loop
|
|
* while restarting the system call, and have it always generate a SIGTTIN
|
|
* or SIGTTOU. The default signal handler will cause the process to stop
|
|
* thus avoiding the infinite loop problem. Presumably the job-control
|
|
* cognizant parent will fix things up before continuging its child process.
|
|
*/
|
|
int tty_signal(int sig, struct tty_struct *tty)
|
|
{
|
|
if (is_orphaned_pgrp(current->pgrp))
|
|
return -EIO; /* don't stop an orphaned pgrp */
|
|
(void) kill_pg(current->pgrp,sig,1);
|
|
if ((current->blocked & (1<<(sig-1))) ||
|
|
((int) current->sigaction[sig-1].sa_handler == 1))
|
|
return -EIO; /* Our signal will be ignored */
|
|
else if (current->sigaction[sig-1].sa_handler)
|
|
return -EINTR; /* We _will_ be interrupted :-) */
|
|
else
|
|
return -ERESTARTSYS; /* We _will_ be interrupted :-) */
|
|
/* (but restart after we continue) */
|
|
}
|
|
|
|
int tty_read(unsigned channel, char * buf, int nr)
|
|
{
|
|
struct tty_struct * tty;
|
|
struct tty_struct * other_tty = NULL;
|
|
char c, * b=buf;
|
|
int minimum,time;
|
|
|
|
if (channel > 255)
|
|
return -EIO;
|
|
tty = TTY_TABLE(channel);
|
|
if (!(tty->write_q || tty->read_q || tty->secondary))
|
|
return -EIO;
|
|
if ((current->tty == channel) && (tty->pgrp != current->pgrp))
|
|
return(tty_signal(SIGTTIN, tty));
|
|
if (channel & 0x80)
|
|
other_tty = tty_table + (channel ^ 0x40);
|
|
time = 10L*tty->termios.c_cc[VTIME];
|
|
minimum = tty->termios.c_cc[VMIN];
|
|
if (L_CANON(tty)) {
|
|
minimum = nr;
|
|
current->timeout = 0xffffffff;
|
|
time = 0;
|
|
} else if (minimum)
|
|
current->timeout = 0xffffffff;
|
|
else {
|
|
minimum = nr;
|
|
if (time)
|
|
current->timeout = time + jiffies;
|
|
time = 0;
|
|
}
|
|
if (minimum>nr)
|
|
minimum = nr;
|
|
while (nr>0) {
|
|
if (other_tty)
|
|
other_tty->write(other_tty);
|
|
cli();
|
|
if (EMPTY(tty->secondary) || (L_CANON(tty) &&
|
|
!FULL(tty->read_q) && !tty->secondary->data)) {
|
|
if (!current->timeout ||
|
|
(current->signal & ~current->blocked)) {
|
|
sti();
|
|
break;
|
|
}
|
|
if (IS_A_PTY_SLAVE(channel) && C_HUP(other_tty))
|
|
break;
|
|
interruptible_sleep_on(&tty->secondary->proc_list);
|
|
sti();
|
|
continue;
|
|
}
|
|
sti();
|
|
do {
|
|
GETCH(tty->secondary,c);
|
|
if ((EOF_CHAR(tty) != _POSIX_VDISABLE &&
|
|
c==EOF_CHAR(tty)) || c==10)
|
|
tty->secondary->data--;
|
|
if ((EOF_CHAR(tty) != _POSIX_VDISABLE &&
|
|
c==EOF_CHAR(tty)) && L_CANON(tty))
|
|
break;
|
|
else {
|
|
put_fs_byte(c,b++);
|
|
if (!--nr)
|
|
break;
|
|
}
|
|
if (c==10 && L_CANON(tty))
|
|
break;
|
|
} while (nr>0 && !EMPTY(tty->secondary));
|
|
wake_up(&tty->read_q->proc_list);
|
|
if (time)
|
|
current->timeout = time+jiffies;
|
|
if (L_CANON(tty) || b-buf >= minimum)
|
|
break;
|
|
}
|
|
current->timeout = 0;
|
|
if ((current->signal & ~current->blocked) && !(b-buf))
|
|
return -ERESTARTSYS;
|
|
return (b-buf);
|
|
}
|
|
|
|
int tty_write(unsigned channel, char * buf, int nr)
|
|
{
|
|
static cr_flag=0;
|
|
struct tty_struct * tty;
|
|
char c, *b=buf;
|
|
|
|
if (channel > 255)
|
|
return -EIO;
|
|
tty = TTY_TABLE(channel);
|
|
if (!(tty->write_q || tty->read_q || tty->secondary))
|
|
return -EIO;
|
|
if (L_TOSTOP(tty) &&
|
|
(current->tty == channel) && (tty->pgrp != current->pgrp))
|
|
return(tty_signal(SIGTTOU, tty));
|
|
while (nr>0) {
|
|
sleep_if_full(tty->write_q);
|
|
if (current->signal & ~current->blocked)
|
|
break;
|
|
while (nr>0 && !FULL(tty->write_q)) {
|
|
c=get_fs_byte(b);
|
|
if (O_POST(tty)) {
|
|
if (c=='\r' && O_CRNL(tty))
|
|
c='\n';
|
|
else if (c=='\n' && O_NLRET(tty))
|
|
c='\r';
|
|
if (c=='\n' && !cr_flag && O_NLCR(tty)) {
|
|
cr_flag = 1;
|
|
PUTCH(13,tty->write_q);
|
|
continue;
|
|
}
|
|
if (O_LCUC(tty))
|
|
c=toupper(c);
|
|
}
|
|
b++; nr--;
|
|
cr_flag = 0;
|
|
PUTCH(c,tty->write_q);
|
|
}
|
|
tty->write(tty);
|
|
if (nr>0)
|
|
schedule();
|
|
}
|
|
return (b-buf);
|
|
}
|
|
|
|
/*
|
|
* Jeh, sometimes I really like the 386.
|
|
* This routine is called from an interrupt,
|
|
* and there should be absolutely no problem
|
|
* with sleeping even in an interrupt (I hope).
|
|
* Of course, if somebody proves me wrong, I'll
|
|
* hate intel for all time :-). We'll have to
|
|
* be careful and see to reinstating the interrupt
|
|
* chips before calling this, though.
|
|
*
|
|
* I don't think we sleep here under normal circumstances
|
|
* anyway, which is good, as the task sleeping might be
|
|
* totally innocent.
|
|
*/
|
|
void do_tty_interrupt(int tty)
|
|
{
|
|
copy_to_cooked(TTY_TABLE(tty));
|
|
}
|
|
|
|
void chr_dev_init(void)
|
|
{
|
|
}
|
|
|
|
void tty_init(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0 ; i < QUEUES ; i++)
|
|
tty_queues[i] = (struct tty_queue) {0,0,0,0,""};
|
|
rs_queues[0] = (struct tty_queue) {0x3f8,0,0,0,""};
|
|
rs_queues[1] = (struct tty_queue) {0x3f8,0,0,0,""};
|
|
rs_queues[3] = (struct tty_queue) {0x2f8,0,0,0,""};
|
|
rs_queues[4] = (struct tty_queue) {0x2f8,0,0,0,""};
|
|
for (i=0 ; i<256 ; i++) {
|
|
tty_table[i] = (struct tty_struct) {
|
|
{0, 0, 0, 0, 0, INIT_C_CC},
|
|
0, 0, 0, NULL, NULL, NULL, NULL
|
|
};
|
|
}
|
|
con_init();
|
|
for (i = 0 ; i<NR_CONSOLES ; i++) {
|
|
con_table[i] = (struct tty_struct) {
|
|
{ICRNL, /* change incoming CR to NL */
|
|
OPOST|ONLCR, /* change outgoing NL to CRNL */
|
|
0,
|
|
IXON | ISIG | ICANON | ECHO | ECHOCTL | ECHOKE,
|
|
0, /* console termio */
|
|
INIT_C_CC},
|
|
0, /* initial pgrp */
|
|
0, /* initial session */
|
|
0, /* initial stopped */
|
|
con_write,
|
|
con_queues+0+i*3,con_queues+1+i*3,con_queues+2+i*3
|
|
};
|
|
}
|
|
for (i = 0 ; i<NR_SERIALS ; i++) {
|
|
rs_table[i] = (struct tty_struct) {
|
|
{0, /* no translation */
|
|
0, /* no translation */
|
|
B2400 | CS8,
|
|
0,
|
|
0,
|
|
INIT_C_CC},
|
|
0,
|
|
0,
|
|
0,
|
|
rs_write,
|
|
rs_queues+0+i*3,rs_queues+1+i*3,rs_queues+2+i*3
|
|
};
|
|
}
|
|
for (i = 0 ; i<NR_PTYS ; i++) {
|
|
mpty_table[i] = (struct tty_struct) {
|
|
{0, /* no translation */
|
|
0, /* no translation */
|
|
B9600 | CS8,
|
|
0,
|
|
0,
|
|
INIT_C_CC},
|
|
0,
|
|
0,
|
|
0,
|
|
mpty_write,
|
|
mpty_queues+0+i*3,mpty_queues+1+i*3,mpty_queues+2+i*3
|
|
};
|
|
spty_table[i] = (struct tty_struct) {
|
|
{0, /* no translation */
|
|
0, /* no translation */
|
|
B9600 | CS8,
|
|
IXON | ISIG | ICANON,
|
|
0,
|
|
INIT_C_CC},
|
|
0,
|
|
0,
|
|
0,
|
|
spty_write,
|
|
spty_queues+0+i*3,spty_queues+1+i*3,spty_queues+2+i*3
|
|
};
|
|
}
|
|
rs_init();
|
|
printk("%d virtual consoles\n\r",NR_CONSOLES);
|
|
printk("%d pty's\n\r",NR_PTYS);
|
|
}
|