void wait_until_sent(struct tty_struct * tty, int timeout)
{
struct wait_queue wait = { current, NULL };
TTY_WRITE_FLUSH(tty);
if (EMPTY(&tty->write_q))
return;
add_wait_queue(&tty->write_q.proc_list, &wait);
current->counter = 0; /* make us low-priority */
if (timeout)
current->timeout = timeout + jiffies;
else
current->timeout = (unsigned) -1;
do {
current->state = TASK_INTERRUPTIBLE;
if (current->signal & ~current->blocked)
break;
TTY_WRITE_FLUSH(tty);
if (EMPTY(&tty->write_q))
break;
schedule();
} while (current->timeout);
current->state = TASK_RUNNING;
remove_wait_queue(&tty->write_q.proc_list, &wait);
}
void wait_until_sent(struct tty_struct * tty)
{
struct wait_queue wait = { current, NULL };
TTY_WRITE_FLUSH(tty);
if (EMPTY(&tty->write_q))
return;
add_wait_queue(&tty->write_q.proc_list, &wait);
current->counter = 0; /* make us low-priority */
while (1) {
current->state = TASK_INTERRUPTIBLE;
if (current->signal & ~current->blocked)
break;
TTY_WRITE_FLUSH(tty);
if (EMPTY(&tty->write_q))
break;
schedule();
}
current->state = TASK_RUNNING;
remove_wait_queue(&tty->write_q.proc_list, &wait);
}
static int write_chan(struct tty_struct * tty, struct file * file,
unsigned char * buf, unsigned int nr)
{
struct wait_queue wait = { current, NULL };
int c;
unsigned char *b = buf;
int retval = 0;
/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
if (L_TOSTOP(tty) && file->f_inode->i_rdev != CONSOLE_DEV) {
retval = check_change(tty, tty->line);
if (retval)
return retval;
}
add_wait_queue(&tty->write_q.proc_list, &wait);
while (1) {
current->state = TASK_INTERRUPTIBLE;
if (current->signal & ~current->blocked) {
retval = -ERESTARTSYS;
break;
}
if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
retval = -EIO;
break;
}
while (nr > 0) {
c = get_fs_byte(b);
/* Care is needed here: opost() can abort even
if the write_q is not full. */
if (opost(c, tty) < 0)
break;
b++; nr--;
}
TTY_WRITE_FLUSH(tty);
if (!nr)
break;
if (EMPTY(&tty->write_q) && !need_resched)
continue;
if (file->f_flags & O_NONBLOCK) {
retval = -EAGAIN;
break;
}
schedule();
}
current->state = TASK_RUNNING;
remove_wait_queue(&tty->write_q.proc_list, &wait);
return (b - buf) ? b - buf : retval;
}
void wait_until_sent(struct tty_struct * tty)
{
while (!(current->signal & ~current->blocked) &&
!EMPTY(&tty->write_q)) {
TTY_WRITE_FLUSH(tty);
current->counter = 0;
cli();
if (EMPTY(&tty->write_q))
break;
else
interruptible_sleep_on(&tty->write_q.proc_list);
sti();
}
sti();
}
static inline int input_available_p(struct tty_struct *tty)
{
/* Avoid calling TTY_READ_FLUSH unnecessarily. */
if (L_ICANON(tty) ? tty->canon_data : !EMPTY(&tty->secondary))
return 1;
/* Shuffle any pending data down the queues. */
TTY_READ_FLUSH(tty);
if (tty->link)
TTY_WRITE_FLUSH(tty->link);
if (L_ICANON(tty) ? tty->canon_data : !EMPTY(&tty->secondary))
return 1;
return 0;
}
void start_tty(struct tty_struct *tty)
{
if (!tty->stopped)
return;
tty->stopped = 0;
if (tty->link && tty->link->packet) {
tty->ctrl_status &= ~TIOCPKT_STOP;
tty->ctrl_status |= TIOCPKT_START;
wake_up_interruptible(&tty->link->secondary.proc_list);
}
if (tty->start)
(tty->start)(tty);
TTY_WRITE_FLUSH(tty);
if (IS_A_CONSOLE(tty->line)) {
clr_vc_kbd_led(kbd_table + fg_console, VC_SCROLLOCK);
set_leds();
}
}
int tty_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned int arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
int pgrp;
int dev;
if (MAJOR(file->f_rdev) != 4) {
printk("tty_ioctl: tty pseudo-major != 4\n");
return -EINVAL;
}
dev = MINOR(file->f_rdev);
tty = TTY_TABLE(dev);
if (!tty)
return -EINVAL;
if (IS_A_PTY(dev))
other_tty = tty_table[PTY_OTHER(dev)];
else
other_tty = NULL;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush_input(tty);
/* fallthrough */
case TCSETSW:
wait_until_sent(tty);
/* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg, dev);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush_input(tty);
/* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg, dev);
case TCXONC:
switch (arg) {
case TCOOFF:
tty->stopped = 1;
TTY_WRITE_FLUSH(tty);
return 0;
case TCOON:
tty->stopped = 0;
TTY_WRITE_FLUSH(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
put_tty_queue(STOP_CHAR(tty),
&tty->write_q);
return 0;
case TCION:
if (START_CHAR(tty))
put_tty_queue(START_CHAR(tty),
&tty->write_q);
return 0;
}
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0)
flush_input(tty);
else if (arg==1)
flush_output(tty);
else if (arg==2) {
flush_input(tty);
flush_output(tty);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
if ((current->tty < 0) ||
(current->tty != dev) ||
(tty->session != current->session))
return -ENOTTY;
pgrp=get_fs_long((unsigned long *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(&tty->write_q),
(unsigned long *) arg);
return 0;
case TIOCINQ:
verify_area((void *) arg,4);
if (L_CANON(tty) && !tty->secondary.data)
put_fs_long(0, (unsigned long *) arg);
else
put_fs_long(CHARS(&tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return get_window_size(tty,(struct winsize *) arg);
case TIOCSWINSZ:
if (IS_A_PTY_MASTER(dev))
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
default:
return -EINVAL;
}
case TIOCCONS:
if (!IS_A_PTY(dev))
return -EINVAL;
if (redirect)
return -EBUSY;
if (!suser())
return -EPERM;
if (IS_A_PTY_MASTER(dev))
redirect = other_tty;
else
redirect = tty;
return 0;
case FIONBIO:
if (arg)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
return 0;
case TIOCNOTTY:
if (MINOR(file->f_rdev) != current->tty)
return -EINVAL;
current->tty = -1;
if (current->leader) {
if (tty->pgrp > 0)
kill_pg(tty->pgrp, SIGHUP, 0);
tty->pgrp = -1;
tty->session = 0;
}
return 0;
case TIOCPKT:
{
int on;
if (!IS_A_PTY_MASTER(dev))
return (-EINVAL);
verify_area ((unsigned long *)arg, sizeof (int));
on=get_fs_long ((unsigned long *)arg);
if (on )
tty->packet = 1;
else
tty->packet = 0;
return (0);
}
default:
if (tty->ioctl)
return (tty->ioctl)(tty, file, cmd, arg);
else
return -EINVAL;
}
}
static void copy_to_cooked(struct tty_struct * tty)
{
int c, special_flag;
unsigned long flags;
if (!tty) {
printk("copy_to_cooked: called with NULL tty\n");
return;
}
if (!tty->write) {
printk("copy_to_cooked: tty %d has null write routine\n",
tty->line);
}
while (1) {
/*
* Check to see how much room we have left in the
* secondary queue. Send a throttle command or abort
* if necessary.
*/
c = LEFT(&tty->secondary);
if (tty->throttle && (c < SQ_THRESHOLD_LW)
&& !set_bit(TTY_SQ_THROTTLED, &tty->flags))
tty->throttle(tty, TTY_THROTTLE_SQ_FULL);
if (c == 0)
break;
save_flags(flags); cli();
if (!EMPTY(&tty->read_q)) {
c = tty->read_q.buf[tty->read_q.tail];
special_flag = clear_bit(tty->read_q.tail,
&tty->readq_flags);
INC(tty->read_q.tail);
restore_flags(flags);
} else {
restore_flags(flags);
break;
}
if (special_flag) {
tty->char_error = c;
continue;
}
if (tty->char_error) {
if (tty->char_error == TTY_BREAK) {
tty->char_error = 0;
if (I_IGNBRK(tty))
continue;
/* A break is handled by the lower levels. */
if (I_BRKINT(tty))
continue;
if (I_PARMRK(tty)) {
put_tty_queue('\377', &tty->secondary);
put_tty_queue('\0', &tty->secondary);
}
put_tty_queue('\0', &tty->secondary);
continue;
}
if (tty->char_error == TTY_OVERRUN) {
tty->char_error = 0;
printk("tty%d: input overrun\n", tty->line);
continue;
}
/* Must be a parity or frame error */
tty->char_error = 0;
if (I_IGNPAR(tty)) {
continue;
}
if (I_PARMRK(tty)) {
put_tty_queue('\377', &tty->secondary);
put_tty_queue('\0', &tty->secondary);
put_tty_queue(c, &tty->secondary);
} else
put_tty_queue('\0', &tty->secondary);
continue;
}
if (I_ISTRIP(tty))
c &= 0x7f;
if (!tty->lnext) {
if (c == '\r') {
if (I_IGNCR(tty))
continue;
if (I_ICRNL(tty))
c = '\n';
} else if (c == '\n' && I_INLCR(tty))
c = '\r';
}
if (I_IUCLC(tty) && L_IEXTEN(tty))
c=tolower(c);
if (c == __DISABLED_CHAR)
tty->lnext = 1;
if (L_ICANON(tty) && !tty->lnext) {
if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
(c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
eraser(c, tty);
continue;
}
if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
tty->lnext = 1;
if (L_ECHO(tty)) {
if (tty->erasing) {
opost('/', tty);
tty->erasing = 0;
}
if (L_ECHOCTL(tty)) {
opost('^', tty);
opost('\b', tty);
}
}
continue;
}
if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
L_IEXTEN(tty)) {
unsigned long tail = tty->canon_head;
if (tty->erasing) {
opost('/', tty);
tty->erasing = 0;
}
echo_char(c, tty);
opost('\n', tty);
while (tail != tty->secondary.head) {
echo_char(tty->secondary.buf[tail],
tty);
INC(tail);
}
continue;
}
}
if (I_IXON(tty) && !tty->lnext) {
if ((tty->stopped && I_IXANY(tty) && L_IEXTEN(tty)) ||
c == START_CHAR(tty)) {
start_tty(tty);
continue;
}
if (c == STOP_CHAR(tty)) {
stop_tty(tty);
continue;
}
}
if (L_ISIG(tty) && !tty->lnext) {
if (c == INTR_CHAR(tty)) {
isig(SIGINT, tty);
continue;
}
if (c == QUIT_CHAR(tty)) {
isig(SIGQUIT, tty);
continue;
}
if (c == SUSP_CHAR(tty)) {
if (!is_orphaned_pgrp(tty->pgrp))
isig(SIGTSTP, tty);
continue;
}
}
if (tty->erasing) {
opost('/', tty);
tty->erasing = 0;
}
if (c == '\n' && !tty->lnext) {
if (L_ECHO(tty) || (L_ICANON(tty) && L_ECHONL(tty)))
opost('\n', tty);
} else if (L_ECHO(tty)) {
/* Don't echo the EOF char in canonical mode. Sun
handles this differently by echoing the char and
then backspacing, but that's a hack. */
if (c != EOF_CHAR(tty) || !L_ICANON(tty) ||
tty->lnext) {
/* Record the column of first canon char. */
if (tty->canon_head == tty->secondary.head)
tty->canon_column = tty->column;
echo_char(c, tty);
}
}
if (I_PARMRK(tty) && c == (unsigned char) '\377' &&
(c != EOF_CHAR(tty) || !L_ICANON(tty) || tty->lnext))
put_tty_queue(c, &tty->secondary);
if (L_ICANON(tty) && !tty->lnext &&
(c == '\n' || c == EOF_CHAR(tty) || c == EOL_CHAR(tty) ||
(c == EOL2_CHAR(tty) && L_IEXTEN(tty)))) {
if (c == EOF_CHAR(tty))
c = __DISABLED_CHAR;
set_bit(tty->secondary.head, &tty->secondary_flags);
put_tty_queue(c, &tty->secondary);
tty->canon_head = tty->secondary.head;
tty->canon_data++;
} else
put_tty_queue(c, &tty->secondary);
tty->lnext = 0;
}
if (!EMPTY(&tty->write_q))
TTY_WRITE_FLUSH(tty);
if (L_ICANON(tty) ? tty->canon_data : !EMPTY(&tty->secondary))
wake_up_interruptible(&tty->secondary.proc_list);
if (tty->throttle && (LEFT(&tty->read_q) >= RQ_THRESHOLD_HW)
&& clear_bit(TTY_RQ_THROTTLED, &tty->flags))
tty->throttle(tty, TTY_THROTTLE_RQ_AVAIL);
}
