drivers/char/pty.c

/* */
This source file includes following definitions.
pty_close
pty_copy
pty_write
pty_open
   1 /*
   2  *  linux/kernel/chr_drv/pty.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6 
   7 /*
   8  *      pty.c
   9  *
  10  * This module exports the following pty function:
  11  * 
  12  *      int  pty_open(struct tty_struct * tty, struct file * filp);
  13  */
  14 
  15 #include <linux/errno.h>
  16 #include <linux/sched.h>
  17 #include <linux/tty.h>
  18 #include <linux/fcntl.h>
  19 #include <linux/interrupt.h>
  20 
  21 #include <asm/system.h>
  22 #include <asm/bitops.h>
  23 
  24 static void pty_close(struct tty_struct * tty, struct file * filp)
     /*  */
  25 {
  26         if (!tty)
  27                 return;
  28         if (IS_A_PTY_MASTER(tty->line)) {
  29                 if (tty->count > 1)
  30                         return;
  31         } else {
  32                 if (tty->count > 2)
  33                         return;
  34         }
  35         wake_up_interruptible(&tty->secondary.proc_list);
  36         wake_up_interruptible(&tty->read_q.proc_list);
  37         wake_up_interruptible(&tty->write_q.proc_list);
  38         if (!tty->link)
  39                 return;
  40         wake_up_interruptible(&tty->link->secondary.proc_list);
  41         wake_up_interruptible(&tty->link->read_q.proc_list);
  42         wake_up_interruptible(&tty->link->write_q.proc_list);
  43         if (IS_A_PTY_MASTER(tty->line)) {
  44                 tty_hangup(tty->link);
  45                 flush_input(tty);
  46                 flush_output(tty);
  47         }
  48 }
  49 
  50 static inline void pty_copy(struct tty_struct * from, struct tty_struct * to)
     /*  */
  51 {
  52         int c;
  53 
  54         while (!from->stopped && !EMPTY(&from->write_q)) {
  55                 if (FULL(&to->read_q)) {
  56                         TTY_READ_FLUSH(to);
  57                         if (FULL(&to->read_q))
  58                                 break;
  59                         continue;
  60                 }
  61                 c = get_tty_queue(&from->write_q);
  62                 put_tty_queue(c, &to->read_q);
  63                 if (current->signal & ~current->blocked)
  64                         break;
  65         }
  66         TTY_READ_FLUSH(to);
  67         if (!FULL(&from->write_q))
  68                 wake_up_interruptible(&from->write_q.proc_list);
  69         if (from->write_data_cnt) {
  70                 set_bit(from->line, &tty_check_write);
  71                 mark_bh(TTY_BH);
  72         }
  73 }
  74 
  75 /*
  76  * This routine gets called when tty_write has put something into
  77  * the write_queue. It copies the input to the output-queue of its
  78  * slave.
  79  */
  80 static void pty_write(struct tty_struct * tty)
     /*  */
  81 {
  82         if (tty->link)
  83                 pty_copy(tty,tty->link);
  84 }
  85 
  86 int pty_open(struct tty_struct *tty, struct file * filp)
     /*  */
  87 {
  88         if (!tty || !tty->link)
  89                 return -ENODEV;
  90         if (IS_A_PTY_MASTER(tty->line))
  91                 clear_bit(TTY_SLAVE_OPENED, &tty->flags);
  92         else
  93                 set_bit(TTY_SLAVE_OPENED, &tty->link->flags);
  94         tty->write = tty->link->write = pty_write;
  95         tty->close = tty->link->close = pty_close;
  96         wake_up_interruptible(&tty->read_q.proc_list);
  97         if (filp->f_flags & O_NDELAY)
  98                 return 0;
  99         while (!tty->link->count && !(current->signal & ~current->blocked))
 100                 interruptible_sleep_on(&tty->link->read_q.proc_list);
 101         if (!tty->link->count)
 102                 return -ERESTARTSYS;
 103         return 0;
 104 }
/* */
root/drivers/char/pty.c

DEFINITIONS
