开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
tty_io.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：60k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

tty_io.c：源码内容
  1. /*
  2.  *  linux/drivers/char/tty_io.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  */
  7. /*
  8.  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
  9.  * or rs-channels. It also implements echoing, cooked mode etc.
  10.  *
  11.  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  12.  *
  13.  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  14.  * tty_struct and tty_queue structures.  Previously there was an array
  15.  * of 256 tty_struct's which was statically allocated, and the
  16.  * tty_queue structures were allocated at boot time.  Both are now
  17.  * dynamically allocated only when the tty is open.
  18.  *
  19.  * Also restructured routines so that there is more of a separation
  20.  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  21.  * the low-level tty routines (serial.c, pty.c, console.c).  This
  22.  * makes for cleaner and more compact code.  -TYT, 9/17/92 
  23.  *
  24.  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  25.  * which can be dynamically activated and de-activated by the line
  26.  * discipline handling modules (like SLIP).
  27.  *
  28.  * NOTE: pay no attention to the line discipline code (yet); its
  29.  * interface is still subject to change in this version...
  30.  * -- TYT, 1/31/92
  31.  *
  32.  * Added functionality to the OPOST tty handling.  No delays, but all
  33.  * other bits should be there.
  34.  * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  35.  *
  36.  * Rewrote canonical mode and added more termios flags.
  37.  *  -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  38.  *
  39.  * Reorganized FASYNC support so mouse code can share it.
  40.  * -- ctm@ardi.com, 9Sep95
  41.  *
  42.  * New TIOCLINUX variants added.
  43.  * -- mj@k332.feld.cvut.cz, 19-Nov-95
  44.  * 
  45.  * Restrict vt switching via ioctl()
  46.  *      -- grif@cs.ucr.edu, 5-Dec-95
  47.  *
  48.  * Move console and virtual terminal code to more appropriate files,
  49.  * implement CONFIG_VT and generalize console device interface.
  50.  * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
  51.  *
  52.  * Rewrote init_dev and release_dev to eliminate races.
  53.  * -- Bill Hawes <whawes@star.net>, June 97
  54.  *
  55.  * Added devfs support.
  56.  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
  57.  *
  58.  * Added support for a Unix98-style ptmx device.
  59.  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
  60.  *
  61.  * Reduced memory usage for older ARM systems
  62.  *      -- Russell King <rmk@arm.linux.org.uk>
  63.  *
  64.  * Move do_SAK() into process context.  Less stack use in devfs functions.
  65.  * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
  66.  */
  68. #include <linux/config.h>
  69. #include <linux/types.h>
  70. #include <linux/major.h>
  71. #include <linux/errno.h>
  72. #include <linux/signal.h>
  73. #include <linux/fcntl.h>
  74. #include <linux/sched.h>
  75. #include <linux/interrupt.h>
  76. #include <linux/tty.h>
  77. #include <linux/tty_driver.h>
  78. #include <linux/tty_flip.h>
  79. #include <linux/devpts_fs.h>
  80. #include <linux/file.h>
  81. #include <linux/console.h>
  82. #include <linux/timer.h>
  83. #include <linux/ctype.h>
  84. #include <linux/kd.h>
  85. #include <linux/mm.h>
  86. #include <linux/string.h>
  87. #include <linux/slab.h>
  88. #include <linux/poll.h>
  89. #include <linux/proc_fs.h>
  90. #include <linux/init.h>
  91. #include <linux/module.h>
  92. #include <linux/smp_lock.h>
  94. #include <asm/uaccess.h>
  95. #include <asm/system.h>
  96. #include <asm/bitops.h>
  98. #include <linux/kbd_kern.h>
  99. #include <linux/vt_kern.h>
  100. #include <linux/selection.h>
  101. #include <linux/devfs_fs_kernel.h>
  103. #include <linux/kmod.h>
  105. #ifdef CONFIG_VT
  106. extern void con_init_devfs (void);
  107. #endif
  109. extern void disable_early_printk(void);
  111. #define CONSOLE_DEV MKDEV(TTY_MAJOR,0)
  112. #define TTY_DEV MKDEV(TTYAUX_MAJOR,0)
  113. #define SYSCONS_DEV MKDEV(TTYAUX_MAJOR,1)
  114. #define PTMX_DEV MKDEV(TTYAUX_MAJOR,2)
  116. #undef TTY_DEBUG_HANGUP
  118. #define TTY_PARANOIA_CHECK 1
  119. #define CHECK_TTY_COUNT 1
  121. struct termios tty_std_termios; /* for the benefit of tty drivers  */
  122. struct tty_driver *tty_drivers; /* linked list of tty drivers */
  123. struct tty_ldisc ldiscs[NR_LDISCS]; /* line disc dispatch table */
  125. #ifdef CONFIG_UNIX98_PTYS
  126. extern struct tty_driver ptm_driver[]; /* Unix98 pty masters; for /dev/ptmx */
  127. extern struct tty_driver pts_driver[]; /* Unix98 pty slaves;  for /dev/ptmx */
  128. #endif
  130. /*
  131.  * redirect is the pseudo-tty that console output
  132.  * is redirected to if asked by TIOCCONS.
  133.  */
  134. struct tty_struct * redirect;
  136. static void initialize_tty_struct(struct tty_struct *tty);
  138. static ssize_t tty_read(struct file *, char *, size_t, loff_t *);
  139. static ssize_t tty_write(struct file *, const char *, size_t, loff_t *);
  140. static unsigned int tty_poll(struct file *, poll_table *);
  141. static int tty_open(struct inode *, struct file *);
  142. static int tty_release(struct inode *, struct file *);
  143. int tty_ioctl(struct inode * inode, struct file * file,
  144.       unsigned int cmd, unsigned long arg);
  145. static int tty_fasync(int fd, struct file * filp, int on);
  146. extern int vme_scc_init (void);
  147. extern long vme_scc_console_init(void);
  148. extern int serial167_init(void);
  149. extern long serial167_console_init(void);
  150. extern void console_8xx_init(void);
  151. extern int rs_8xx_init(void);
  152. extern void mac_scc_console_init(void);
  153. extern void hwc_console_init(void);
  154. extern void hwc_tty_init(void);
  155. extern void con3215_init(void);
  156. extern void tty3215_init(void);
  157. extern void tub3270_con_init(void);
  158. extern void tub3270_init(void);
  159. extern void rs285_console_init(void);
  160. extern void sa1100_rs_console_init(void);
  161. extern void sgi_serial_console_init(void);
  162. extern void sci_console_init(void);
  163. extern void tx3912_console_init(void);
  164. extern void tx3912_rs_init(void);
  165. extern void txx927_console_init(void);
  166. extern void sb1250_serial_console_init(void);
  168. #ifndef MIN
  169. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  170. #endif
  171. #ifndef MAX
  172. #define MAX(a,b) ((a) < (b) ? (b) : (a))
  173. #endif
  175. static struct tty_struct *alloc_tty_struct(void)
  176. {
  177. struct tty_struct *tty;
  179. tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
  180. if (tty)
  181. memset(tty, 0, sizeof(struct tty_struct));
  182. return tty;
  183. }
  185. static inline void free_tty_struct(struct tty_struct *tty)
  186. {
  187. kfree(tty);
  188. }
  190. /*
  191.  * This routine returns the name of tty.
  192.  */
  193. static char *
  194. _tty_make_name(struct tty_struct *tty, const char *name, char *buf)
  195. {
  196. int idx = (tty)?MINOR(tty->device) - tty->driver.minor_start:0;
  198. if (!tty) /* Hmm.  NULL pointer.  That's fun. */
  199. strcpy(buf, "NULL tty");
  200. else
  201. sprintf(buf, name,
  202. idx + tty->driver.name_base);
  204. return buf;
  205. }
  207. #define TTY_NUMBER(tty) (MINOR((tty)->device) - (tty)->driver.minor_start + 
  208.  (tty)->driver.name_base)
  210. char *tty_name(struct tty_struct *tty, char *buf)
  211. {
  212. return _tty_make_name(tty, (tty)?tty->driver.name:NULL, buf);
  213. }
  215. inline int tty_paranoia_check(struct tty_struct *tty, kdev_t device,
  216.       const char *routine)
  217. {
  218. #ifdef TTY_PARANOIA_CHECK
  219. static const char badmagic[] = KERN_WARNING
  220. "Warning: bad magic number for tty struct (%s) in %sn";
  221. static const char badtty[] = KERN_WARNING
  222. "Warning: null TTY for (%s) in %sn";
  224. if (!tty) {
  225. printk(badtty, kdevname(device), routine);
  226. return 1;
  227. }
  228. if (tty->magic != TTY_MAGIC) {
  229. printk(badmagic, kdevname(device), routine);
  230. return 1;
  231. }
  232. #endif
  233. return 0;
  234. }
  236. static int check_tty_count(struct tty_struct *tty, const char *routine)
  237. {
  238. #ifdef CHECK_TTY_COUNT
  239. struct list_head *p;
  240. int count = 0;
  242. file_list_lock();
  243. for(p = tty->tty_files.next; p != &tty->tty_files; p = p->next) {
  244. if(list_entry(p, struct file, f_list)->private_data == tty)
  245. count++;
  246. }
  247. file_list_unlock();
  248. if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  249.     tty->driver.subtype == PTY_TYPE_SLAVE &&
  250.     tty->link && tty->link->count)
  251. count++;
  252. if (tty->count != count) {
  253. printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
  254.     "!= #fd's(%d) in %sn",
  255.        kdevname(tty->device), tty->count, count, routine);
  256. return count;
  257.        }
  258. #endif
  259. return 0;
  260. }
  262. int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
  263. {
  264. if (disc < N_TTY || disc >= NR_LDISCS)
  265. return -EINVAL;
  267. if (new_ldisc) {
  268. ldiscs[disc] = *new_ldisc;
  269. ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
  270. ldiscs[disc].num = disc;
  271. } else
  272. memset(&ldiscs[disc], 0, sizeof(struct tty_ldisc));
  274. return 0;
  275. }
  277. EXPORT_SYMBOL(tty_register_ldisc);
  279. /* Set the discipline of a tty line. */
  280. static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
  281. {
  282. int retval = 0;
  283. struct tty_ldisc o_ldisc;
  284. char buf[64];
  286. if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
  287. return -EINVAL;
  288. /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
  289. /* Cyrus Durgin <cider@speakeasy.org> */
  290. if (!(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED)) {
  291. char modname [20];
  292. sprintf(modname, "tty-ldisc-%d", ldisc);
  293. request_module (modname);
  294. }
  295. if (!(ldiscs[ldisc].flags & LDISC_FLAG_DEFINED))
  296. return -EINVAL;
  298. if (tty->ldisc.num == ldisc)
  299. return 0; /* We are already in the desired discipline */
  300. o_ldisc = tty->ldisc;
  302. tty_wait_until_sent(tty, 0);
  304. /* Shutdown the current discipline. */
  305. if (tty->ldisc.close)
  306. (tty->ldisc.close)(tty);
  308. /* Now set up the new line discipline. */
  309. tty->ldisc = ldiscs[ldisc];
  310. tty->termios->c_line = ldisc;
  311. if (tty->ldisc.open)
  312. retval = (tty->ldisc.open)(tty);
  313. if (retval < 0) {
  314. tty->ldisc = o_ldisc;
  315. tty->termios->c_line = tty->ldisc.num;
  316. if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
  317. tty->ldisc = ldiscs[N_TTY];
  318. tty->termios->c_line = N_TTY;
  319. if (tty->ldisc.open) {
  320. int r = tty->ldisc.open(tty);
  322. if (r < 0)
  323. panic("Couldn't open N_TTY ldisc for "
  324.       "%s --- error %d.",
  325.       tty_name(tty, buf), r);
  326. }
  327. }
  328. }
  329. if (tty->ldisc.num != o_ldisc.num && tty->driver.set_ldisc)
  330. tty->driver.set_ldisc(tty);
  331. return retval;
  332. }
  334. /*
  335.  * This routine returns a tty driver structure, given a device number
  336.  */
  337. struct tty_driver *get_tty_driver(kdev_t device)
  338. {
  339. int major, minor;
  340. struct tty_driver *p;
  342. minor = MINOR(device);
  343. major = MAJOR(device);
  345. for (p = tty_drivers; p; p = p->next) {
  346. if (p->major != major)
  347. continue;
  348. if (minor < p->minor_start)
  349. continue;
  350. if (minor >= p->minor_start + p->num)
  351. continue;
  352. return p;
  353. }
  354. return NULL;
  355. }
  357. /*
  358.  * If we try to write to, or set the state of, a terminal and we're
  359.  * not in the foreground, send a SIGTTOU.  If the signal is blocked or
  360.  * ignored, go ahead and perform the operation.  (POSIX 7.2)
  361.  */
  362. int tty_check_change(struct tty_struct * tty)
  363. {
  364. if (current->tty != tty)
  365. return 0;
  366. if (tty->pgrp <= 0) {
  367. printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!n");
  368. return 0;
  369. }
  370. if (current->pgrp == tty->pgrp)
  371. return 0;
  372. if (is_ignored(SIGTTOU))
  373. return 0;
  374. if (is_orphaned_pgrp(current->pgrp))
  375. return -EIO;
  376. (void) kill_pg(current->pgrp,SIGTTOU,1);
  377. return -ERESTARTSYS;
  378. }
  380. static ssize_t hung_up_tty_read(struct file * file, char * buf,
  381. size_t count, loff_t *ppos)
  382. {
  383. /* Can't seek (pread) on ttys.  */
  384. if (ppos != &file->f_pos)
  385. return -ESPIPE;
  386. return 0;
  387. }
  389. static ssize_t hung_up_tty_write(struct file * file, const char * buf,
  390.  size_t count, loff_t *ppos)
  391. {
  392. /* Can't seek (pwrite) on ttys.  */
  393. if (ppos != &file->f_pos)
  394. return -ESPIPE;
  395. return -EIO;
  396. }
  398. /* No kernel lock held - none needed ;) */
  399. static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
  400. {
  401. return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
  402. }
  404. static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
  405.      unsigned int cmd, unsigned long arg)
  406. {
  407. return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
  408. }
  410. static struct file_operations tty_fops = {
  411. llseek: no_llseek,
  412. read: tty_read,
  413. write: tty_write,
  414. poll: tty_poll,
  415. ioctl: tty_ioctl,
  416. open: tty_open,
  417. release: tty_release,
  418. fasync: tty_fasync,
  419. };
  421. static struct file_operations hung_up_tty_fops = {
  422. llseek: no_llseek,
  423. read: hung_up_tty_read,
  424. write: hung_up_tty_write,
  425. poll: hung_up_tty_poll,
  426. ioctl: hung_up_tty_ioctl,
  427. release: tty_release,
  428. };
  430. /*
  431.  * This can be called by the "eventd" kernel thread.  That is process synchronous,
  432.  * but doesn't hold any locks, so we need to make sure we have the appropriate
  433.  * locks for what we're doing..
  434.  */
  435. void do_tty_hangup(void *data)
  436. {
  437. struct tty_struct *tty = (struct tty_struct *) data;
  438. struct file * cons_filp = NULL;
  439. struct task_struct *p;
  440. struct list_head *l;
  441. int    closecount = 0, n;
  443. if (!tty)
  444. return;
  446. /* inuse_filps is protected by the single kernel lock */
  447. lock_kernel();
  449. check_tty_count(tty, "do_tty_hangup");
  450. file_list_lock();
  451. for (l = tty->tty_files.next; l != &tty->tty_files; l = l->next) {
  452. struct file * filp = list_entry(l, struct file, f_list);
  453. if (filp->f_dentry->d_inode->i_rdev == CONSOLE_DEV ||
  454.     filp->f_dentry->d_inode->i_rdev == SYSCONS_DEV) {
  455. cons_filp = filp;
  456. continue;
  457. }
  458. if (filp->f_op != &tty_fops)
  459. continue;
  460. closecount++;
  461. tty_fasync(-1, filp, 0); /* can't block */
  462. filp->f_op = &hung_up_tty_fops;
  463. }
  464. file_list_unlock();
  466. /* FIXME! What are the locking issues here? This may me overdoing things.. */
  467. {
  468. unsigned long flags;
  470. save_flags(flags); cli();
  471. if (tty->ldisc.flush_buffer)
  472. tty->ldisc.flush_buffer(tty);
  473. if (tty->driver.flush_buffer)
  474. tty->driver.flush_buffer(tty);
  475. if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
  476.     tty->ldisc.write_wakeup)
  477. (tty->ldisc.write_wakeup)(tty);
  478. restore_flags(flags);
  479. }
  481. wake_up_interruptible(&tty->write_wait);
  482. wake_up_interruptible(&tty->read_wait);
  484. /*
  485.  * Shutdown the current line discipline, and reset it to
  486.  * N_TTY.
  487.  */
  488. if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS)
  489. *tty->termios = tty->driver.init_termios;
  490. if (tty->ldisc.num != ldiscs[N_TTY].num) {
  491. if (tty->ldisc.close)
  492. (tty->ldisc.close)(tty);
  493. tty->ldisc = ldiscs[N_TTY];
  494. tty->termios->c_line = N_TTY;
  495. if (tty->ldisc.open) {
  496. int i = (tty->ldisc.open)(tty);
  497. if (i < 0)
  498. printk(KERN_ERR "do_tty_hangup: N_TTY open: "
  499. "error %dn", -i);
  500. }
  501. }
  503. read_lock(&tasklist_lock);
  504.   for_each_task(p) {
  505. if ((tty->session > 0) && (p->session == tty->session) &&
  506.     p->leader) {
  507. send_sig(SIGHUP,p,1);
  508. send_sig(SIGCONT,p,1);
  509. if (tty->pgrp > 0)
  510. p->tty_old_pgrp = tty->pgrp;
  511. }
  512. if (p->tty == tty)
  513. p->tty = NULL;
  514. }
  515. read_unlock(&tasklist_lock);
  517. tty->flags = 0;
  518. tty->session = 0;
  519. tty->pgrp = -1;
  520. tty->ctrl_status = 0;
  521. /*
  522.  * If one of the devices matches a console pointer, we
  523.  * cannot just call hangup() because that will cause
  524.  * tty->count and state->count to go out of sync.
  525.  * So we just call close() the right number of times.
  526.  */
  527. if (cons_filp) {
  528. if (tty->driver.close)
  529. for (n = 0; n < closecount; n++)
  530. tty->driver.close(tty, cons_filp);
  531. } else if (tty->driver.hangup)
  532. (tty->driver.hangup)(tty);
  533. unlock_kernel();
  534. }
  536. void tty_hangup(struct tty_struct * tty)
  537. {
  538. #ifdef TTY_DEBUG_HANGUP
  539. char buf[64];
  541. printk(KERN_DEBUG "%s hangup...n", tty_name(tty, buf));
  542. #endif
  543. schedule_task(&tty->tq_hangup);
  544. }
  546. void tty_vhangup(struct tty_struct * tty)
  547. {
  548. #ifdef TTY_DEBUG_HANGUP
  549. char buf[64];
  551. printk(KERN_DEBUG "%s vhangup...n", tty_name(tty, buf));
  552. #endif
  553. do_tty_hangup((void *) tty);
  554. }
  556. int tty_hung_up_p(struct file * filp)
  557. {
  558. return (filp->f_op == &hung_up_tty_fops);
  559. }
  561. /*
  562.  * This function is typically called only by the session leader, when
  563.  * it wants to disassociate itself from its controlling tty.
  564.  *
  565.  * It performs the following functions:
  566.  *  (1)  Sends a SIGHUP and SIGCONT to the foreground process group
  567.  *  (2)  Clears the tty from being controlling the session
  568.  *  (3)  Clears the controlling tty for all processes in the
  569.  *  session group.
  570.  *
  571.  * The argument on_exit is set to 1 if called when a process is
  572.  * exiting; it is 0 if called by the ioctl TIOCNOTTY.
  573.  */
  574. void disassociate_ctty(int on_exit)
  575. {
  576. struct tty_struct *tty = current->tty;
  577. struct task_struct *p;
  578. int tty_pgrp = -1;
  580. if (tty) {
  581. tty_pgrp = tty->pgrp;
  582. if (on_exit && tty->driver.type != TTY_DRIVER_TYPE_PTY)
  583. tty_vhangup(tty);
  584. } else {
  585. if (current->tty_old_pgrp) {
  586. kill_pg(current->tty_old_pgrp, SIGHUP, on_exit);
  587. kill_pg(current->tty_old_pgrp, SIGCONT, on_exit);
  588. }
  589. return;
  590. }
  591. if (tty_pgrp > 0) {
  592. kill_pg(tty_pgrp, SIGHUP, on_exit);
  593. if (!on_exit)
  594. kill_pg(tty_pgrp, SIGCONT, on_exit);
  595. }
  597. current->tty_old_pgrp = 0;
  598. tty->session = 0;
  599. tty->pgrp = -1;
  601. read_lock(&tasklist_lock);
  602. for_each_task(p)
  603.    if (p->session == current->session)
  604. p->tty = NULL;
  605. read_unlock(&tasklist_lock);
  606. }
  608. void stop_tty(struct tty_struct *tty)
  609. {
  610. if (tty->stopped)
  611. return;
  612. tty->stopped = 1;
  613. if (tty->link && tty->link->packet) {
  614. tty->ctrl_status &= ~TIOCPKT_START;
  615. tty->ctrl_status |= TIOCPKT_STOP;
  616. wake_up_interruptible(&tty->link->read_wait);
  617. }
  618. if (tty->driver.stop)
  619. (tty->driver.stop)(tty);
  620. }
  622. void start_tty(struct tty_struct *tty)
  623. {
  624. if (!tty->stopped || tty->flow_stopped)
  625. return;
  626. tty->stopped = 0;
  627. if (tty->link && tty->link->packet) {
  628. tty->ctrl_status &= ~TIOCPKT_STOP;
  629. tty->ctrl_status |= TIOCPKT_START;
  630. wake_up_interruptible(&tty->link->read_wait);
  631. }
  632. if (tty->driver.start)
  633. (tty->driver.start)(tty);
  634. if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
  635.     tty->ldisc.write_wakeup)
  636. (tty->ldisc.write_wakeup)(tty);
  637. wake_up_interruptible(&tty->write_wait);
  638. }
  640. static ssize_t tty_read(struct file * file, char * buf, size_t count, 
  641. loff_t *ppos)
  642. {
  643. int i;
  644. struct tty_struct * tty;
  645. struct inode *inode;
  647. /* Can't seek (pread) on ttys.  */
  648. if (ppos != &file->f_pos)
  649. return -ESPIPE;
  651. tty = (struct tty_struct *)file->private_data;
  652. inode = file->f_dentry->d_inode;
  653. if (tty_paranoia_check(tty, inode->i_rdev, "tty_read"))
  654. return -EIO;
  655. if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
  656. return -EIO;
  658. /* This check not only needs to be done before reading, but also
  659.    whenever read_chan() gets woken up after sleeping, so I've
  660.    moved it to there.  This should only be done for the N_TTY
  661.    line discipline, anyway.  Same goes for write_chan(). -- jlc. */
  662. #if 0
  663. if ((inode->i_rdev != CONSOLE_DEV) && /* don't stop on /dev/console */
  664.     (tty->pgrp > 0) &&
  665.     (current->tty == tty) &&
  666.     (tty->pgrp != current->pgrp))
  667. if (is_ignored(SIGTTIN) || is_orphaned_pgrp(current->pgrp))
  668. return -EIO;
  669. else {
  670. (void) kill_pg(current->pgrp, SIGTTIN, 1);
  671. return -ERESTARTSYS;
  672. }
  673. #endif
  674. lock_kernel();
  675. if (tty->ldisc.read)
  676. i = (tty->ldisc.read)(tty,file,buf,count);
  677. else
  678. i = -EIO;
  679. unlock_kernel();
  680. if (i > 0)
  681. inode->i_atime = CURRENT_TIME;
  682. return i;
  683. }
  685. /*
  686.  * Split writes up in sane blocksizes to avoid
  687.  * denial-of-service type attacks
  688.  */
  689. static inline ssize_t do_tty_write(
  690. ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
  691. struct tty_struct *tty,
  692. struct file *file,
  693. const unsigned char *buf,
  694. size_t count)
  695. {
  696. ssize_t ret = 0, written = 0;
  698. if (file->f_flags & O_NONBLOCK) {
  699. if (down_trylock(&tty->atomic_write))
  700. return -EAGAIN;
  701. }
  702. else {
  703. if (down_interruptible(&tty->atomic_write))
  704. return -ERESTARTSYS;
  705. }
  706. if ( test_bit(TTY_NO_WRITE_SPLIT, &tty->flags) ) {
  707. lock_kernel();
  708. written = write(tty, file, buf, count);
  709. unlock_kernel();
  710. } else {
  711. for (;;) {
  712. unsigned long size = MAX(PAGE_SIZE*2,16384);
  713. if (size > count)
  714. size = count;
  715. lock_kernel();
  716. ret = write(tty, file, buf, size);
  717. unlock_kernel();
  718. if (ret <= 0)
  719. break;
  720. written += ret;
  721. buf += ret;
  722. count -= ret;
  723. if (!count)
  724. break;
  725. ret = -ERESTARTSYS;
  726. if (signal_pending(current))
  727. break;
  728. if (current->need_resched)
  729. schedule();
  730. }
  731. }
  732. if (written) {
  733. file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
  734. ret = written;
  735. }
  736. up(&tty->atomic_write);
  737. return ret;
  738. }
  741. static ssize_t tty_write(struct file * file, const char * buf, size_t count,
  742.  loff_t *ppos)
  743. {
  744. int is_console;
  745. struct tty_struct * tty;
  746. struct inode *inode;
  748. /* Can't seek (pwrite) on ttys.  */
  749. if (ppos != &file->f_pos)
  750. return -ESPIPE;
  752. /*
  753.  *      For now, we redirect writes from /dev/console as
  754.  *      well as /dev/tty0.
  755.  */
  756. inode = file->f_dentry->d_inode;
  757. is_console = (inode->i_rdev == SYSCONS_DEV ||
  758.       inode->i_rdev == CONSOLE_DEV);
  760. if (is_console && redirect)
  761. tty = redirect;
  762. else
  763. tty = (struct tty_struct *)file->private_data;
  764. if (tty_paranoia_check(tty, inode->i_rdev, "tty_write"))
  765. return -EIO;
  766. if (!tty || !tty->driver.write || (test_bit(TTY_IO_ERROR, &tty->flags)))
  767. return -EIO;
  768. #if 0
  769. if (!is_console && L_TOSTOP(tty) && (tty->pgrp > 0) &&
  770.     (current->tty == tty) && (tty->pgrp != current->pgrp)) {
  771. if (is_orphaned_pgrp(current->pgrp))
  772. return -EIO;
  773. if (!is_ignored(SIGTTOU)) {
  774. (void) kill_pg(current->pgrp, SIGTTOU, 1);
  775. return -ERESTARTSYS;
  776. }
  777. }
  778. #endif
  779. if (!tty->ldisc.write)
  780. return -EIO;
  781. return do_tty_write(tty->ldisc.write, tty, file,
  782.     (const unsigned char *)buf, count);
  783. }
  785. /* Semaphore to protect creating and releasing a tty */
  786. static DECLARE_MUTEX(tty_sem);
  788. static void down_tty_sem(int index)
  789. {
  790. down(&tty_sem);
  791. }
  793. static void up_tty_sem(int index)
  794. {
  795. up(&tty_sem);
  796. }
  798. static void release_mem(struct tty_struct *tty, int idx);
  800. /*
  801.  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
  802.  * failed open.  The new code protects the open with a semaphore, so it's
  803.  * really quite straightforward.  The semaphore locking can probably be
  804.  * relaxed for the (most common) case of reopening a tty.
  805.  */
  806. static int init_dev(kdev_t device, struct tty_struct **ret_tty)
  807. {
  808. struct tty_struct *tty, *o_tty;
  809. struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
  810. struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
  811. struct tty_driver *driver;
  812. int retval=0;
  813. int idx;
  815. driver = get_tty_driver(device);
  816. if (!driver)
  817. return -ENODEV;
  819. idx = MINOR(device) - driver->minor_start;
  821. /* 
  822.  * Check whether we need to acquire the tty semaphore to avoid
  823.  * race conditions.  For now, play it safe.
  824.  */
  825. down_tty_sem(idx);
  827. /* check whether we're reopening an existing tty */
  828. tty = driver->table[idx];
  829. if (tty) goto fast_track;
  831. /*
  832.  * First time open is complex, especially for PTY devices.
  833.  * This code guarantees that either everything succeeds and the
  834.  * TTY is ready for operation, or else the table slots are vacated
  835.  * and the allocated memory released.  (Except that the termios 
  836.  * and locked termios may be retained.)
  837.  */
  839. o_tty = NULL;
  840. tp = o_tp = NULL;
  841. ltp = o_ltp = NULL;
  843. tty = alloc_tty_struct();
  844. if(!tty)
  845. goto fail_no_mem;
  846. initialize_tty_struct(tty);
  847. tty->device = device;
  848. tty->driver = *driver;
  850. tp_loc = &driver->termios[idx];
  851. if (!*tp_loc) {
  852. tp = (struct termios *) kmalloc(sizeof(struct termios),
  853. GFP_KERNEL);
  854. if (!tp)
  855. goto free_mem_out;
  856. *tp = driver->init_termios;
  857. }
  859. ltp_loc = &driver->termios_locked[idx];
  860. if (!*ltp_loc) {
  861. ltp = (struct termios *) kmalloc(sizeof(struct termios),
  862.  GFP_KERNEL);
  863. if (!ltp)
  864. goto free_mem_out;
  865. memset(ltp, 0, sizeof(struct termios));
  866. }
  868. if (driver->type == TTY_DRIVER_TYPE_PTY) {
  869. o_tty = alloc_tty_struct();
  870. if (!o_tty)
  871. goto free_mem_out;
  872. initialize_tty_struct(o_tty);
  873. o_tty->device = (kdev_t) MKDEV(driver->other->major,
  874. driver->other->minor_start + idx);
  875. o_tty->driver = *driver->other;
  877. o_tp_loc  = &driver->other->termios[idx];
  878. if (!*o_tp_loc) {
  879. o_tp = (struct termios *)
  880. kmalloc(sizeof(struct termios), GFP_KERNEL);
  881. if (!o_tp)
  882. goto free_mem_out;
  883. *o_tp = driver->other->init_termios;
  884. }
  886. o_ltp_loc = &driver->other->termios_locked[idx];
  887. if (!*o_ltp_loc) {
  888. o_ltp = (struct termios *)
  889. kmalloc(sizeof(struct termios), GFP_KERNEL);
  890. if (!o_ltp)
  891. goto free_mem_out;
  892. memset(o_ltp, 0, sizeof(struct termios));
  893. }
  895. /*
  896.  * Everything allocated ... set up the o_tty structure.
  897.  */
  898. driver->other->table[idx] = o_tty;
  899. if (!*o_tp_loc)
  900. *o_tp_loc = o_tp;
  901. if (!*o_ltp_loc)
  902. *o_ltp_loc = o_ltp;
  903. o_tty->termios = *o_tp_loc;
  904. o_tty->termios_locked = *o_ltp_loc;
  905. (*driver->other->refcount)++;
  906. if (driver->subtype == PTY_TYPE_MASTER)
  907. o_tty->count++;
  909. /* Establish the links in both directions */
  910. tty->link   = o_tty;
  911. o_tty->link = tty;
  912. }
  914. /* 
  915.  * All structures have been allocated, so now we install them.
  916.  * Failures after this point use release_mem to clean up, so 
  917.  * there's no need to null out the local pointers.
  918.  */
  919. driver->table[idx] = tty;
  921. if (!*tp_loc)
  922. *tp_loc = tp;
  923. if (!*ltp_loc)
  924. *ltp_loc = ltp;
  925. tty->termios = *tp_loc;
  926. tty->termios_locked = *ltp_loc;
  927. (*driver->refcount)++;
  928. tty->count++;
  930. /* 
  931.  * Structures all installed ... call the ldisc open routines.
  932.  * If we fail here just call release_mem to clean up.  No need
  933.  * to decrement the use counts, as release_mem doesn't care.
  934.  */
  935. if (tty->ldisc.open) {
  936. retval = (tty->ldisc.open)(tty);
  937. if (retval)
  938. goto release_mem_out;
  939. }
  940. if (o_tty && o_tty->ldisc.open) {
  941. retval = (o_tty->ldisc.open)(o_tty);
  942. if (retval) {
  943. if (tty->ldisc.close)
  944. (tty->ldisc.close)(tty);
  945. goto release_mem_out;
  946. }
  947. }
  948. goto success;
  950. /*
  951.  * This fast open can be used if the tty is already open.
  952.  * No memory is allocated, and the only failures are from
  953.  * attempting to open a closing tty or attempting multiple
  954.  * opens on a pty master.
  955.  */
  956. fast_track:
  957. if (test_bit(TTY_CLOSING, &tty->flags)) {
  958. retval = -EIO;
  959. goto end_init;
  960. }
  961. if (driver->type == TTY_DRIVER_TYPE_PTY &&
  962.     driver->subtype == PTY_TYPE_MASTER) {
  963. /*
  964.  * special case for PTY masters: only one open permitted, 
  965.  * and the slave side open count is incremented as well.
  966.  */
  967. if (tty->count) {
  968. retval = -EIO;
  969. goto end_init;
  970. }
  971. tty->link->count++;
  972. }
  973. tty->count++;
  974. tty->driver = *driver; /* N.B. why do this every time?? */
  976. success:
  977. *ret_tty = tty;
  979. /* All paths come through here to release the semaphore */
  980. end_init:
  981. up_tty_sem(idx);
  982. return retval;
  984. /* Release locally allocated memory ... nothing placed in slots */
  985. free_mem_out:
  986. if (o_tp)
  987. kfree(o_tp);
  988. if (o_tty)
  989. free_tty_struct(o_tty);
  990. if (ltp)
  991. kfree(ltp);
  992. if (tp)
  993. kfree(tp);
  994. free_tty_struct(tty);
  996. fail_no_mem:
  997. retval = -ENOMEM;
  998. goto end_init;
  1000. /* call the tty release_mem routine to clean out this slot */
  1001. release_mem_out:
  1002. printk(KERN_INFO "init_dev: ldisc open failed, "
  1003.  "clearing slot %dn", idx);
  1004. release_mem(tty, idx);
  1005. goto end_init;
  1006. }
  1008. /*
  1009.  * Releases memory associated with a tty structure, and clears out the
  1010.  * driver table slots.
  1011.  */
  1012. static void release_mem(struct tty_struct *tty, int idx)
  1013. {
  1014. struct tty_struct *o_tty;
  1015. struct termios *tp;
  1017. if ((o_tty = tty->link) != NULL) {
  1018. o_tty->driver.table[idx] = NULL;
  1019. if (o_tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  1020. tp = o_tty->driver.termios[idx];
  1021. o_tty->driver.termios[idx] = NULL;
  1022. kfree(tp);
  1023. }
  1024. o_tty->magic = 0;
  1025. (*o_tty->driver.refcount)--;
  1026. list_del(&o_tty->tty_files);
  1027. free_tty_struct(o_tty);
  1028. }
  1030. tty->driver.table[idx] = NULL;
  1031. if (tty->driver.flags & TTY_DRIVER_RESET_TERMIOS) {
  1032. tp = tty->driver.termios[idx];
  1033. tty->driver.termios[idx] = NULL;
  1034. kfree(tp);
  1035. }
  1036. tty->magic = 0;
  1037. (*tty->driver.refcount)--;
  1038. list_del(&tty->tty_files);
  1039. free_tty_struct(tty);
  1040. }
  1042. /*
  1043.  * Even releasing the tty structures is a tricky business.. We have
  1044.  * to be very careful that the structures are all released at the
  1045.  * same time, as interrupts might otherwise get the wrong pointers.
  1046.  *
  1047.  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
  1048.  * lead to double frees or releasing memory still in use.
  1049.  */
  1050. static void release_dev(struct file * filp)
  1051. {
  1052. struct tty_struct *tty, *o_tty;
  1053. int pty_master, tty_closing, o_tty_closing, do_sleep;
  1054. int idx;
  1055. char buf[64];
  1057. tty = (struct tty_struct *)filp->private_data;
  1058. if (tty_paranoia_check(tty, filp->f_dentry->d_inode->i_rdev, "release_dev"))
  1059. return;
  1061. check_tty_count(tty, "release_dev");
  1063. tty_fasync(-1, filp, 0);
  1065. idx = MINOR(tty->device) - tty->driver.minor_start;
  1066. pty_master = (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  1067.       tty->driver.subtype == PTY_TYPE_MASTER);
  1068. o_tty = tty->link;
  1070. #ifdef TTY_PARANOIA_CHECK
  1071. if (idx < 0 || idx >= tty->driver.num) {
  1072. printk(KERN_DEBUG "release_dev: bad idx when trying to "
  1073.   "free (%s)n", kdevname(tty->device));
  1074. return;
  1075. }
  1076. if (tty != tty->driver.table[idx]) {
  1077. printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
  1078.   "for (%s)n", idx, kdevname(tty->device));
  1079. return;
  1080. }
  1081. if (tty->termios != tty->driver.termios[idx]) {
  1082. printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
  1083.        "for (%s)n",
  1084.        idx, kdevname(tty->device));
  1085. return;
  1086. }
  1087. if (tty->termios_locked != tty->driver.termios_locked[idx]) {
  1088. printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
  1089.        "termios_locked for (%s)n",
  1090.        idx, kdevname(tty->device));
  1091. return;
  1092. }
  1093. #endif
  1095. #ifdef TTY_DEBUG_HANGUP
  1096. printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
  1097.        tty_name(tty, buf), tty->count);
  1098. #endif
  1100. #ifdef TTY_PARANOIA_CHECK
  1101. if (tty->driver.other) {
  1102. if (o_tty != tty->driver.other->table[idx]) {
  1103. printk(KERN_DEBUG "release_dev: other->table[%d] "
  1104.   "not o_tty for (%s)n",
  1105.        idx, kdevname(tty->device));
  1106. return;
  1107. }
  1108. if (o_tty->termios != tty->driver.other->termios[idx]) {
  1109. printk(KERN_DEBUG "release_dev: other->termios[%d] "
  1110.   "not o_termios for (%s)n",
  1111.        idx, kdevname(tty->device));
  1112. return;
  1113. }
  1114. if (o_tty->termios_locked != 
  1115.       tty->driver.other->termios_locked[idx]) {
  1116. printk(KERN_DEBUG "release_dev: other->termios_locked["
  1117.   "%d] not o_termios_locked for (%s)n",
  1118.        idx, kdevname(tty->device));
  1119. return;
  1120. }
  1121. if (o_tty->link != tty) {
  1122. printk(KERN_DEBUG "release_dev: bad pty pointersn");
  1123. return;
  1124. }
  1125. }
  1126. #endif
  1128. if (tty->driver.close)
  1129. tty->driver.close(tty, filp);
  1131. /*
  1132.  * Sanity check: if tty->count is going to zero, there shouldn't be
  1133.  * any waiters on tty->read_wait or tty->write_wait.  We test the
  1134.  * wait queues and kick everyone out _before_ actually starting to
  1135.  * close.  This ensures that we won't block while releasing the tty
  1136.  * structure.
  1137.  *
  1138.  * The test for the o_tty closing is necessary, since the master and
  1139.  * slave sides may close in any order.  If the slave side closes out
  1140.  * first, its count will be one, since the master side holds an open.
  1141.  * Thus this test wouldn't be triggered at the time the slave closes,
  1142.  * so we do it now.
  1143.  *
  1144.  * Note that it's possible for the tty to be opened again while we're
  1145.  * flushing out waiters.  By recalculating the closing flags before
  1146.  * each iteration we avoid any problems.
  1147.  */
  1148. while (1) {
  1149. tty_closing = tty->count <= 1;
  1150. o_tty_closing = o_tty &&
  1151. (o_tty->count <= (pty_master ? 1 : 0));
  1152. do_sleep = 0;
  1154. if (tty_closing) {
  1155. if (waitqueue_active(&tty->read_wait)) {
  1156. wake_up(&tty->read_wait);
  1157. do_sleep++;
  1158. }
  1159. if (waitqueue_active(&tty->write_wait)) {
  1160. wake_up(&tty->write_wait);
  1161. do_sleep++;
  1162. }
  1163. }
  1164. if (o_tty_closing) {
  1165. if (waitqueue_active(&o_tty->read_wait)) {
  1166. wake_up(&o_tty->read_wait);
  1167. do_sleep++;
  1168. }
  1169. if (waitqueue_active(&o_tty->write_wait)) {
  1170. wake_up(&o_tty->write_wait);
  1171. do_sleep++;
  1172. }
  1173. }
  1174. if (!do_sleep)
  1175. break;
  1177. printk(KERN_WARNING "release_dev: %s: read/write wait queue "
  1178.     "active!n", tty_name(tty, buf));
  1179. schedule();
  1180. }
  1182. /*
  1183.  * The closing flags are now consistent with the open counts on 
  1184.  * both sides, and we've completed the last operation that could 
  1185.  * block, so it's safe to proceed with closing.
  1186.  */
  1187. if (pty_master) {
  1188. if (--o_tty->count < 0) {
  1189. printk(KERN_WARNING "release_dev: bad pty slave count "
  1190.     "(%d) for %sn",
  1191.        o_tty->count, tty_name(o_tty, buf));
  1192. o_tty->count = 0;
  1193. }
  1194. }
  1195. if (--tty->count < 0) {
  1196. printk(KERN_WARNING "release_dev: bad tty->count (%d) for %sn",
  1197.        tty->count, tty_name(tty, buf));
  1198. tty->count = 0;
  1199. }
  1201. /*
  1202.  * We've decremented tty->count, so we should zero out
  1203.  * filp->private_data, to break the link between the tty and
  1204.  * the file descriptor.  Otherwise if filp_close() blocks before
  1205.  * the file descriptor is removed from the inuse_filp
  1206.  * list, check_tty_count() could observe a discrepancy and
  1207.  * printk a warning message to the user.
  1208.  */
  1209. filp->private_data = 0;
  1211. /*
  1212.  * Perform some housekeeping before deciding whether to return.
  1213.  *
  1214.  * Set the TTY_CLOSING flag if this was the last open.  In the
  1215.  * case of a pty we may have to wait around for the other side
  1216.  * to close, and TTY_CLOSING makes sure we can't be reopened.
  1217.  */
  1218. if(tty_closing)
  1219. set_bit(TTY_CLOSING, &tty->flags);
  1220. if(o_tty_closing)
  1221. set_bit(TTY_CLOSING, &o_tty->flags);
  1223. /*
  1224.  * If _either_ side is closing, make sure there aren't any
  1225.  * processes that still think tty or o_tty is their controlling
  1226.  * tty.  Also, clear redirect if it points to either tty.
  1227.  */
  1228. if (tty_closing || o_tty_closing) {
  1229. struct task_struct *p;
  1231. read_lock(&tasklist_lock);
  1232. for_each_task(p) {
  1233. if (p->tty == tty || (o_tty && p->tty == o_tty))
  1234. p->tty = NULL;
  1235. }
  1236. read_unlock(&tasklist_lock);
  1238. if (redirect == tty || (o_tty && redirect == o_tty))
  1239. redirect = NULL;
  1240. }
  1242. /* check whether both sides are closing ... */
  1243. if (!tty_closing || (o_tty && !o_tty_closing))
  1244. return;
  1246. #ifdef TTY_DEBUG_HANGUP
  1247. printk(KERN_DEBUG "freeing tty structure...");
  1248. #endif
  1250. /*
  1251.  * Shutdown the current line discipline, and reset it to N_TTY.
  1252.  * N.B. why reset ldisc when we're releasing the memory??
  1253.  */
  1254. if (tty->ldisc.close)
  1255. (tty->ldisc.close)(tty);
  1256. tty->ldisc = ldiscs[N_TTY];
  1257. tty->termios->c_line = N_TTY;
  1258. if (o_tty) {
  1259. if (o_tty->ldisc.close)
  1260. (o_tty->ldisc.close)(o_tty);
  1261. o_tty->ldisc = ldiscs[N_TTY];
  1262. }
  1264. /*
  1265.  * Make sure that the tty's task queue isn't activated. 
  1266.  */
  1267. run_task_queue(&tq_timer);
  1268. flush_scheduled_tasks();
  1270. /* 
  1271.  * The release_mem function takes care of the details of clearing
  1272.  * the slots and preserving the termios structure.
  1273.  */
  1274. release_mem(tty, idx);
  1275. }
  1277. /*
  1278.  * tty_open and tty_release keep up the tty count that contains the
  1279.  * number of opens done on a tty. We cannot use the inode-count, as
  1280.  * different inodes might point to the same tty.
  1281.  *
  1282.  * Open-counting is needed for pty masters, as well as for keeping
  1283.  * track of serial lines: DTR is dropped when the last close happens.
  1284.  * (This is not done solely through tty->count, now.  - Ted 1/27/92)
  1285.  *
  1286.  * The termios state of a pty is reset on first open so that
  1287.  * settings don't persist across reuse.
  1288.  */
  1289. static int tty_open(struct inode * inode, struct file * filp)
  1290. {
  1291. struct tty_struct *tty;
  1292. int noctty, retval;
  1293. kdev_t device;
  1294. unsigned short saved_flags;
  1295. char buf[64];
  1297. saved_flags = filp->f_flags;
  1298. retry_open:
  1299. noctty = filp->f_flags & O_NOCTTY;
  1300. device = inode->i_rdev;
  1301. if (device == TTY_DEV) {
  1302. if (!current->tty)
  1303. return -ENXIO;
  1304. device = current->tty->device;
  1305. filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
  1306. /* noctty = 1; */
  1307. }
  1308. #ifdef CONFIG_VT
  1309. if (device == CONSOLE_DEV) {
  1310. extern int fg_console;
  1311. device = MKDEV(TTY_MAJOR, fg_console + 1);
  1312. noctty = 1;
  1313. }
  1314. #endif
  1315. if (device == SYSCONS_DEV) {
  1316. struct console *c = console_drivers;
  1317. while(c && !c->device)
  1318. c = c->next;
  1319. if (!c)
  1320.                         return -ENODEV;
  1321.                 device = c->device(c);
  1322. filp->f_flags |= O_NONBLOCK; /* Don't let /dev/console block */
  1323. noctty = 1;
  1324. }
  1326. if (device == PTMX_DEV) {
  1327. #ifdef CONFIG_UNIX98_PTYS
  1329. /* find a free pty. */
  1330. int major, minor;
  1331. struct tty_driver *driver;
  1333. /* find a device that is not in use. */
  1334. retval = -1;
  1335. for ( major = 0 ; major < UNIX98_NR_MAJORS ; major++ ) {
  1336. driver = &ptm_driver[major];
  1337. for (minor = driver->minor_start ;
  1338.      minor < driver->minor_start + driver->num ;
  1339.      minor++) {
  1340. device = MKDEV(driver->major, minor);
  1341. if (!init_dev(device, &tty)) goto ptmx_found; /* ok! */
  1342. }
  1343. }
  1344. return -EIO; /* no free ptys */
  1345. ptmx_found:
  1346. set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
  1347. minor -= driver->minor_start;
  1348. devpts_pty_new(driver->other->name_base + minor, MKDEV(driver->other->major, minor + driver->other->minor_start));
  1349. tty_register_devfs(&pts_driver[major], DEVFS_FL_DEFAULT,
  1350.    pts_driver[major].minor_start + minor);
  1351. noctty = 1;
  1352. goto init_dev_done;
  1354. #else   /* CONFIG_UNIX_98_PTYS */
  1356. return -ENODEV;
  1358. #endif  /* CONFIG_UNIX_98_PTYS */
  1359. }
  1361. retval = init_dev(device, &tty);
  1362. if (retval)
  1363. return retval;
  1365. #ifdef CONFIG_UNIX98_PTYS
  1366. init_dev_done:
  1367. #endif
  1368. filp->private_data = tty;
  1369. file_move(filp, &tty->tty_files);
  1370. check_tty_count(tty, "tty_open");
  1371. if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  1372.     tty->driver.subtype == PTY_TYPE_MASTER)
  1373. noctty = 1;
  1374. #ifdef TTY_DEBUG_HANGUP
  1375. printk(KERN_DEBUG "opening %s...", tty_name(tty, buf));
  1376. #endif
  1377. if (tty->driver.open)
  1378. retval = tty->driver.open(tty, filp);
  1379. else
  1380. retval = -ENODEV;
  1381. filp->f_flags = saved_flags;
  1383. if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !suser())
  1384. retval = -EBUSY;
  1386. if (retval) {
  1387. #ifdef TTY_DEBUG_HANGUP
  1388. printk(KERN_DEBUG "error %d in opening %s...", retval,
  1389.        tty_name(tty, buf));
  1390. #endif
  1392. release_dev(filp);
  1393. if (retval != -ERESTARTSYS)
  1394. return retval;
  1395. if (signal_pending(current))
  1396. return retval;
  1397. schedule();
  1398. /*
  1399.  * Need to reset f_op in case a hangup happened.
  1400.  */
  1401. filp->f_op = &tty_fops;
  1402. goto retry_open;
  1403. }
  1404. if (!noctty &&
  1405.     current->leader &&
  1406.     !current->tty &&
  1407.     tty->session == 0) {
  1408.      task_lock(current);
  1409. current->tty = tty;
  1410. task_unlock(current);
  1411. current->tty_old_pgrp = 0;
  1412. tty->session = current->session;
  1413. tty->pgrp = current->pgrp;
  1414. }
  1415. if ((tty->driver.type == TTY_DRIVER_TYPE_SERIAL) &&
  1416.     (tty->driver.subtype == SERIAL_TYPE_CALLOUT) &&
  1417.     (tty->count == 1)) {
  1418. static int nr_warns;
  1419. if (nr_warns < 5) {
  1420. printk(KERN_WARNING "tty_io.c: "
  1421. "process %d (%s) used obsolete /dev/%s - "
  1422. "update software to use /dev/ttyS%dn",
  1423. current->pid, current->comm,
  1424. tty_name(tty, buf), TTY_NUMBER(tty));
  1425. nr_warns++;
  1426. }
  1427. }
  1428. return 0;
  1429. }
  1431. static int tty_release(struct inode * inode, struct file * filp)
  1432. {
  1433. lock_kernel();
  1434. release_dev(filp);
  1435. unlock_kernel();
  1436. return 0;
  1437. }
  1439. /* No kernel lock held - fine */
  1440. static unsigned int tty_poll(struct file * filp, poll_table * wait)
  1441. {
  1442. struct tty_struct * tty;
  1444. tty = (struct tty_struct *)filp->private_data;
  1445. if (tty_paranoia_check(tty, filp->f_dentry->d_inode->i_rdev, "tty_poll"))
  1446. return 0;
  1448. if (tty->ldisc.poll)
  1449. return (tty->ldisc.poll)(tty, filp, wait);
  1450. return 0;
  1451. }
  1453. static int tty_fasync(int fd, struct file * filp, int on)
  1454. {
  1455. struct tty_struct * tty;
  1456. int retval;
  1458. tty = (struct tty_struct *)filp->private_data;
  1459. if (tty_paranoia_check(tty, filp->f_dentry->d_inode->i_rdev, "tty_fasync"))
  1460. return 0;
  1462. retval = fasync_helper(fd, filp, on, &tty->fasync);
  1463. if (retval <= 0)
  1464. return retval;
  1466. if (on) {
  1467. if (!waitqueue_active(&tty->read_wait))
  1468. tty->minimum_to_wake = 1;
  1469. if (filp->f_owner.pid == 0) {
  1470. filp->f_owner.pid = (-tty->pgrp) ? : current->pid;
  1471. filp->f_owner.uid = current->uid;
  1472. filp->f_owner.euid = current->euid;
  1473. }
  1474. } else {
  1475. if (!tty->fasync && !waitqueue_active(&tty->read_wait))
  1476. tty->minimum_to_wake = N_TTY_BUF_SIZE;
  1477. }
  1478. return 0;
  1479. }
  1481. static int tiocsti(struct tty_struct *tty, char * arg)
  1482. {
  1483. char ch, mbz = 0;
  1485. if ((current->tty != tty) && !suser())
  1486. return -EPERM;
  1487. if (get_user(ch, arg))
  1488. return -EFAULT;
  1489. tty->ldisc.receive_buf(tty, &ch, &mbz, 1);
  1490. return 0;
  1491. }
  1493. static int tiocgwinsz(struct tty_struct *tty, struct winsize * arg)
  1494. {
  1495. if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
  1496. return -EFAULT;
  1497. return 0;
  1498. }
  1500. static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
  1501. struct winsize * arg)
  1502. {
  1503. struct winsize tmp_ws;
  1505. if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
  1506. return -EFAULT;
  1507. if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
  1508. return 0;
  1509. if (tty->pgrp > 0)
  1510. kill_pg(tty->pgrp, SIGWINCH, 1);
  1511. if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
  1512. kill_pg(real_tty->pgrp, SIGWINCH, 1);
  1513. tty->winsize = tmp_ws;
  1514. real_tty->winsize = tmp_ws;
  1515. return 0;
  1516. }
  1518. static int tioccons(struct inode *inode,
  1519. struct tty_struct *tty, struct tty_struct *real_tty)
  1520. {
  1521. if (inode->i_rdev == SYSCONS_DEV ||
  1522.     inode->i_rdev == CONSOLE_DEV) {
  1523. if (!suser())
  1524. return -EPERM;
  1525. redirect = NULL;
  1526. return 0;
  1527. }
  1528. if (redirect)
  1529. return -EBUSY;
  1530. redirect = real_tty;
  1531. return 0;
  1532. }
  1535. static int fionbio(struct file *file, int *arg)
  1536. {
  1537. int nonblock;
  1539. if (get_user(nonblock, arg))
  1540. return -EFAULT;
  1542. if (nonblock)
  1543. file->f_flags |= O_NONBLOCK;
  1544. else
  1545. file->f_flags &= ~O_NONBLOCK;
  1546. return 0;
  1547. }
  1549. static int tiocsctty(struct tty_struct *tty, int arg)
  1550. {
  1551. if (current->leader &&
  1552.     (current->session == tty->session))
  1553. return 0;
  1554. /*
  1555.  * The process must be a session leader and
  1556.  * not have a controlling tty already.
  1557.  */
  1558. if (!current->leader || current->tty)
  1559. return -EPERM;
  1560. if (tty->session > 0) {
  1561. /*
  1562.  * This tty is already the controlling
  1563.  * tty for another session group!
  1564.  */
  1565. if ((arg == 1) && suser()) {
  1566. /*
  1567.  * Steal it away
  1568.  */
  1569. struct task_struct *p;
  1571. read_lock(&tasklist_lock);
  1572. for_each_task(p)
  1573. if (p->tty == tty)
  1574. p->tty = NULL;
  1575. read_unlock(&tasklist_lock);
  1576. } else
  1577. return -EPERM;
  1578. }
  1579. task_lock(current);
  1580. current->tty = tty;
  1581. task_unlock(current);
  1582. current->tty_old_pgrp = 0;
  1583. tty->session = current->session;
  1584. tty->pgrp = current->pgrp;
  1585. return 0;
  1586. }
  1588. static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t *arg)
  1589. {
  1590. /*
  1591.  * (tty == real_tty) is a cheap way of
  1592.  * testing if the tty is NOT a master pty.
  1593.  */
  1594. if (tty == real_tty && current->tty != real_tty)
  1595. return -ENOTTY;
  1596. return put_user(real_tty->pgrp, arg);
  1597. }
  1599. static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t *arg)
  1600. {
  1601. pid_t pgrp;
  1602. int retval = tty_check_change(real_tty);
  1604. if (retval == -EIO)
  1605. return -ENOTTY;
  1606. if (retval)
  1607. return retval;
  1608. if (!current->tty ||
  1609.     (current->tty != real_tty) ||
  1610.     (real_tty->session != current->session))
  1611. return -ENOTTY;
  1612. if (get_user(pgrp, (pid_t *) arg))
  1613. return -EFAULT;
  1614. if (pgrp < 0)
  1615. return -EINVAL;
  1616. if (session_of_pgrp(pgrp) != current->session)
  1617. return -EPERM;
  1618. real_tty->pgrp = pgrp;
  1619. return 0;
  1620. }
  1622. static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t *arg)
  1623. {
  1624. /*
  1625.  * (tty == real_tty) is a cheap way of
  1626.  * testing if the tty is NOT a master pty.
  1627. */
  1628. if (tty == real_tty && current->tty != real_tty)
  1629. return -ENOTTY;
  1630. if (real_tty->session <= 0)
  1631. return -ENOTTY;
  1632. return put_user(real_tty->session, arg);
  1633. }
  1635. static int tiocttygstruct(struct tty_struct *tty, struct tty_struct *arg)
  1636. {
  1637. if (copy_to_user(arg, tty, sizeof(*arg)))
  1638. return -EFAULT;
  1639. return 0;
  1640. }
  1642. static int tiocsetd(struct tty_struct *tty, int *arg)
  1643. {
  1644. int ldisc;
  1646. if (get_user(ldisc, arg))
  1647. return -EFAULT;
  1648. return tty_set_ldisc(tty, ldisc);
  1649. }
  1651. static int send_break(struct tty_struct *tty, int duration)
  1652. {
  1653. set_current_state(TASK_INTERRUPTIBLE);
  1655. tty->driver.break_ctl(tty, -1);
  1656. if (!signal_pending(current))
  1657. schedule_timeout(duration);
  1658. tty->driver.break_ctl(tty, 0);
  1659. if (signal_pending(current))
  1660. return -EINTR;
  1661. return 0;
  1662. }
  1664. static int tty_generic_brk(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
  1665. {
  1666. if (cmd == TCSBRK && arg) 
  1667. {
  1668. /* tcdrain case */
  1669. int retval = tty_check_change(tty);
  1670. if (retval)
  1671. return retval;
  1672. tty_wait_until_sent(tty, 0);
  1673. if (signal_pending(current))
  1674. return -EINTR;
  1675. }
  1676. return 0;
  1677. }
  1679. /*
  1680.  * Split this up, as gcc can choke on it otherwise..
  1681.  */
  1682. int tty_ioctl(struct inode * inode, struct file * file,
  1683.       unsigned int cmd, unsigned long arg)
  1684. {
  1685. struct tty_struct *tty, *real_tty;
  1686. int retval;
  1688. tty = (struct tty_struct *)file->private_data;
  1689. if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
  1690. return -EINVAL;
  1692. real_tty = tty;
  1693. if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  1694.     tty->driver.subtype == PTY_TYPE_MASTER)
  1695. real_tty = tty->link;
  1697. /*
  1698.  * Break handling by driver
  1699.  */
  1700. if (!tty->driver.break_ctl) {
  1701. switch(cmd) {
  1702. case TIOCSBRK:
  1703. case TIOCCBRK:
  1704. if (tty->driver.ioctl)
  1705. return tty->driver.ioctl(tty, file, cmd, arg);
  1706. return -EINVAL;
  1708. /* These two ioctl's always return success; even if */
  1709. /* the driver doesn't support them. */
  1710. case TCSBRK:
  1711. case TCSBRKP:
  1712. retval = -ENOIOCTLCMD;
  1713. if (tty->driver.ioctl)
  1714. retval = tty->driver.ioctl(tty, file, cmd, arg);
  1715. /* Not driver handled */
  1716. if (retval == -ENOIOCTLCMD)
  1717. retval = tty_generic_brk(tty, file, cmd, arg);
  1718. return retval;
  1719. }
  1720. }
  1722. /*
  1723.  * Factor out some common prep work
  1724.  */
  1725. switch (cmd) {
  1726. case TIOCSETD:
  1727. case TIOCSBRK:
  1728. case TIOCCBRK:
  1729. case TCSBRK:
  1730. case TCSBRKP:
  1731. retval = tty_check_change(tty);
  1732. if (retval)
  1733. return retval;
  1734. if (cmd != TIOCCBRK) {
  1735. tty_wait_until_sent(tty, 0);
  1736. if (signal_pending(current))
  1737. return -EINTR;
  1738. }
  1739. break;
  1740. }
  1742. switch (cmd) {
  1743. case TIOCSTI:
  1744. return tiocsti(tty, (char *)arg);
  1745. case TIOCGWINSZ:
  1746. return tiocgwinsz(tty, (struct winsize *) arg);
  1747. case TIOCSWINSZ:
  1748. return tiocswinsz(tty, real_tty, (struct winsize *) arg);
  1749. case TIOCCONS:
  1750. return tioccons(inode, tty, real_tty);
  1751. case FIONBIO:
  1752. return fionbio(file, (int *) arg);
  1753. case TIOCEXCL:
  1754. set_bit(TTY_EXCLUSIVE, &tty->flags);
  1755. return 0;
  1756. case TIOCNXCL:
  1757. clear_bit(TTY_EXCLUSIVE, &tty->flags);
  1758. return 0;
  1759. case TIOCNOTTY:
  1760. if (current->tty != tty)
  1761. return -ENOTTY;
  1762. if (current->leader)
  1763. disassociate_ctty(0);
  1764. task_lock(current);
  1765. current->tty = NULL;
  1766. task_unlock(current);
  1767. return 0;
  1768. case TIOCSCTTY:
  1769. return tiocsctty(tty, arg);
  1770. case TIOCGPGRP:
  1771. return tiocgpgrp(tty, real_tty, (pid_t *) arg);
  1772. case TIOCSPGRP:
  1773. return tiocspgrp(tty, real_tty, (pid_t *) arg);
  1774. case TIOCGSID:
  1775. return tiocgsid(tty, real_tty, (pid_t *) arg);
  1776. case TIOCGETD:
  1777. return put_user(tty->ldisc.num, (int *) arg);
  1778. case TIOCSETD:
  1779. return tiocsetd(tty, (int *) arg);
  1780. #ifdef CONFIG_VT
  1781. case TIOCLINUX:
  1782. return tioclinux(tty, arg);
  1783. #endif
  1784. case TIOCTTYGSTRUCT:
  1785. return tiocttygstruct(tty, (struct tty_struct *) arg);
  1787. /*
  1788.  * Break handling
  1789.  */
  1790. case TIOCSBRK: /* Turn break on, unconditionally */
  1791. tty->driver.break_ctl(tty, -1);
  1792. return 0;
  1794. case TIOCCBRK: /* Turn break off, unconditionally */
  1795. tty->driver.break_ctl(tty, 0);
  1796. return 0;
  1797. case TCSBRK:   /* SVID version: non-zero arg --> no break */
  1798. /*
  1799.  * XXX is the above comment correct, or the
  1800.  * code below correct?  Is this ioctl used at
  1801.  * all by anyone?
  1802.  */
  1803. if (!arg)
  1804. return send_break(tty, HZ/4);
  1805. return 0;
  1806. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1807. return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
  1808. }
  1809. if (tty->driver.ioctl) {
  1810. int retval = (tty->driver.ioctl)(tty, file, cmd, arg);
  1811. if (retval != -ENOIOCTLCMD)
  1812. return retval;
  1813. }
  1814. if (tty->ldisc.ioctl) {
  1815. int retval = (tty->ldisc.ioctl)(tty, file, cmd, arg);
  1816. if (retval != -ENOIOCTLCMD)
  1817. return retval;
  1818. }
  1819. return -EINVAL;
  1820. }
  1823. /*
  1824.  * This implements the "Secure Attention Key" ---  the idea is to
  1825.  * prevent trojan horses by killing all processes associated with this
  1826.  * tty when the user hits the "Secure Attention Key".  Required for
  1827.  * super-paranoid applications --- see the Orange Book for more details.
  1828.  * 
  1829.  * This code could be nicer; ideally it should send a HUP, wait a few
  1830.  * seconds, then send a INT, and then a KILL signal.  But you then
  1831.  * have to coordinate with the init process, since all processes associated
  1832.  * with the current tty must be dead before the new getty is allowed
  1833.  * to spawn.
  1834.  *
  1835.  * Now, if it would be correct ;-/ The current code has a nasty hole -
  1836.  * it doesn't catch files in flight. We may send the descriptor to ourselves
  1837.  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
  1838.  *
  1839.  * Nasty bug: do_SAK is being called in interrupt context.  This can
  1840.  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
  1841.  */
  1842. static void __do_SAK(void *arg)
  1843. {
  1844. #ifdef TTY_SOFT_SAK
  1845. tty_hangup(tty);
  1846. #else
  1847. struct tty_struct *tty = arg;
  1848. struct task_struct *p;
  1849. int session;
  1850. int i;
  1851. struct file *filp;
  1853. if (!tty)
  1854. return;
  1855. session  = tty->session;
  1856. if (tty->ldisc.flush_buffer)
  1857. tty->ldisc.flush_buffer(tty);
  1858. if (tty->driver.flush_buffer)
  1859. tty->driver.flush_buffer(tty);
  1860. read_lock(&tasklist_lock);
  1861. for_each_task(p) {
  1862. if ((p->tty == tty) ||
  1863.     ((session > 0) && (p->session == session))) {
  1864. send_sig(SIGKILL, p, 1);
  1865. continue;
  1866. }
  1867. task_lock(p);
  1868. if (p->files) {
  1869. read_lock(&p->files->file_lock);
  1870. for (i=0; i < p->files->max_fds; i++) {
  1871. filp = fcheck_files(p->files, i);
  1872. if (filp && (filp->f_op == &tty_fops) &&
  1873.     (filp->private_data == tty)) {
  1874. send_sig(SIGKILL, p, 1);
  1875. break;
  1876. }
  1877. }
  1878. read_unlock(&p->files->file_lock);
  1879. }
  1880. task_unlock(p);
  1881. }
  1882. read_unlock(&tasklist_lock);
  1883. #endif
  1884. }
  1886. /*
  1887.  * The tq handling here is a little racy - tty->SAK_tq may already be queued.
  1888.  * But there's no mechanism to fix that without futzing with tqueue_lock.
  1889.  * Fortunately we don't need to worry, because if ->SAK_tq is already queued,
  1890.  * the values which we write to it will be identical to the values which it
  1891.  * already has. --akpm
  1892.  */
  1893. void do_SAK(struct tty_struct *tty)
  1894. {
  1895. if (!tty)
  1896. return;
  1897. PREPARE_TQUEUE(&tty->SAK_tq, __do_SAK, tty);
  1898. schedule_task(&tty->SAK_tq);
  1899. }
  1901. /*
  1902.  * This routine is called out of the software interrupt to flush data
  1903.  * from the flip buffer to the line discipline.
  1904.  */
  1905. static void flush_to_ldisc(void *private_)
  1906. {
  1907. struct tty_struct *tty = (struct tty_struct *) private_;
  1908. unsigned char *cp;
  1909. char *fp;
  1910. int count;
  1911. unsigned long flags;
  1913. if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
  1914. queue_task(&tty->flip.tqueue, &tq_timer);
  1915. return;
  1916. }
  1917. if (tty->flip.buf_num) {
  1918. cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  1919. fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  1920. tty->flip.buf_num = 0;
  1922. save_flags(flags); cli();
  1923. tty->flip.char_buf_ptr = tty->flip.char_buf;
  1924. tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  1925. } else {
  1926. cp = tty->flip.char_buf;
  1927. fp = tty->flip.flag_buf;
  1928. tty->flip.buf_num = 1;
  1930. save_flags(flags); cli();
  1931. tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
  1932. tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
  1933. }
  1934. count = tty->flip.count;
  1935. tty->flip.count = 0;
  1936. restore_flags(flags);
  1938. tty->ldisc.receive_buf(tty, cp, fp, count);
  1939. }
  1941. /*
  1942.  * Routine which returns the baud rate of the tty
  1943.  *
  1944.  * Note that the baud_table needs to be kept in sync with the
  1945.  * include/asm/termbits.h file.
  1946.  */
  1947. static int baud_table[] = {
  1948. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  1949. 9600, 19200, 38400, 57600, 115200, 230400, 460800,
  1950. #ifdef __sparc__
  1951. 76800, 153600, 307200, 614400, 921600
  1952. #else
  1953. 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
  1954. 2500000, 3000000, 3500000, 4000000
  1955. #endif
  1956. };
  1958. static int n_baud_table = sizeof(baud_table)/sizeof(int);
  1960. int tty_get_baud_rate(struct tty_struct *tty)
  1961. {
  1962. unsigned int cflag, i;
  1964. cflag = tty->termios->c_cflag;
  1966. i = cflag & CBAUD;
  1967. if (i & CBAUDEX) {
  1968. i &= ~CBAUDEX;
  1969. if (i < 1 || i+15 >= n_baud_table) 
  1970. tty->termios->c_cflag &= ~CBAUDEX;
  1971. else
  1972. i += 15;
  1973. }
  1974. if (i==15 && tty->alt_speed) {
  1975. if (!tty->warned) {
  1976. printk(KERN_WARNING "Use of setserial/setrocket to "
  1977.     "set SPD_* flags is deprecatedn");
  1978. tty->warned = 1;
  1979. }
  1980. return(tty->alt_speed);
  1981. }
  1983. return baud_table[i];
  1984. }
  1986. void tty_flip_buffer_push(struct tty_struct *tty)
  1987. {
  1988. if (tty->low_latency)
  1989. flush_to_ldisc((void *) tty);
  1990. else
  1991. queue_task(&tty->flip.tqueue, &tq_timer);
  1992. }
  1994. /*
  1995.  * This subroutine initializes a tty structure.
  1996.  */
  1997. static void initialize_tty_struct(struct tty_struct *tty)
  1998. {
  1999. memset(tty, 0, sizeof(struct tty_struct));
  2000. tty->magic = TTY_MAGIC;
  2001. tty->ldisc = ldiscs[N_TTY];
  2002. tty->pgrp = -1;
  2003. tty->flip.char_buf_ptr = tty->flip.char_buf;
  2004. tty->flip.flag_buf_ptr = tty->flip.flag_buf;
  2005. tty->flip.tqueue.routine = flush_to_ldisc;
  2006. tty->flip.tqueue.data = tty;
  2007. init_MUTEX(&tty->flip.pty_sem);
  2008. init_waitqueue_head(&tty->write_wait);
  2009. init_waitqueue_head(&tty->read_wait);
  2010. tty->tq_hangup.routine = do_tty_hangup;
  2011. tty->tq_hangup.data = tty;
  2012. sema_init(&tty->atomic_read, 1);
  2013. sema_init(&tty->atomic_write, 1);
  2014. spin_lock_init(&tty->read_lock);
  2015. INIT_LIST_HEAD(&tty->tty_files);
  2016. INIT_TQUEUE(&tty->SAK_tq, 0, 0);
  2017. }
  2019. /*
  2020.  * The default put_char routine if the driver did not define one.
  2021.  */
  2022. void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
  2023. {
  2024. tty->driver.write(tty, 0, &ch, 1);
  2025. }
  2027. /*
  2028.  * Register a tty device described by <driver>, with minor number <minor>.
  2029.  */
  2030. void tty_register_devfs (struct tty_driver *driver, unsigned int flags, unsigned minor)
  2031. {
  2032. #ifdef CONFIG_DEVFS_FS
  2033. umode_t mode = S_IFCHR | S_IRUSR | S_IWUSR;
  2034. kdev_t device = MKDEV (driver->major, minor);
  2035. int idx = minor - driver->minor_start;
  2036. char buf[32];
  2038. switch (device) {
  2039. case TTY_DEV:
  2040. case PTMX_DEV:
  2041. mode |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
  2042. break;
  2043. default:
  2044. if (driver->major == PTY_MASTER_MAJOR)
  2045. mode |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
  2046. break;
  2047. }
  2048. if ( (minor <  driver->minor_start) || 
  2049.      (minor >= driver->minor_start + driver->num) ) {
  2050. printk(KERN_ERR "Attempt to register invalid minor number "
  2051.        "with devfs (%d:%d).n", (int)driver->major,(int)minor);
  2052. return;
  2053. }
  2054. #  ifdef CONFIG_UNIX98_PTYS
  2055. if ( (driver->major >= UNIX98_PTY_SLAVE_MAJOR) &&
  2056.      (driver->major < UNIX98_PTY_SLAVE_MAJOR + UNIX98_NR_MAJORS) )
  2057. flags |= DEVFS_FL_CURRENT_OWNER;
  2058. #  endif
  2059. sprintf(buf, driver->name, idx + driver->name_base);
  2060. devfs_register (NULL, buf, flags | DEVFS_FL_DEFAULT,
  2061. driver->major, minor, mode, &tty_fops, NULL);
  2062. #endif /* CONFIG_DEVFS_FS */
  2063. }
  2065. void tty_unregister_devfs (struct tty_driver *driver, unsigned minor)
  2066. {
  2067. #ifdef CONFIG_DEVFS_FS
  2068. void * handle;
  2069. int idx = minor - driver->minor_start;
  2070. char buf[32];
  2072. sprintf(buf, driver->name, idx + driver->name_base);
  2073. handle = devfs_find_handle (NULL, buf, driver->major, minor,
  2074.     DEVFS_SPECIAL_CHR, 0);
  2075. devfs_unregister (handle);
  2076. #endif /* CONFIG_DEVFS_FS */
  2077. }
  2079. EXPORT_SYMBOL(tty_register_devfs);
  2080. EXPORT_SYMBOL(tty_unregister_devfs);
  2082. /*
  2083.  * Called by a tty driver to register itself.
  2084.  */
  2085. int tty_register_driver(struct tty_driver *driver)
  2086. {
  2087. int error;
  2088.         int i;
  2090. if (driver->flags & TTY_DRIVER_INSTALLED)
  2091. return 0;
  2093. error = devfs_register_chrdev(driver->major, driver->name, &tty_fops);
  2094. if (error < 0)
  2095. return error;
  2096. else if(driver->major == 0)
  2097. driver->major = error;
  2099. if (!driver->put_char)
  2100. driver->put_char = tty_default_put_char;
  2102. driver->prev = 0;
  2103. driver->next = tty_drivers;
  2104. if (tty_drivers) tty_drivers->prev = driver;
  2105. tty_drivers = driver;
  2107. if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
  2108. for(i = 0; i < driver->num; i++)
  2109.     tty_register_devfs(driver, 0, driver->minor_start + i);
  2110. }
  2111. proc_tty_register_driver(driver);
  2112. return error;
  2113. }
  2115. /*
  2116.  * Called by a tty driver to unregister itself.
  2117.  */
  2118. int tty_unregister_driver(struct tty_driver *driver)
  2119. {
  2120. int retval;
  2121. struct tty_driver *p;
  2122. int i, found = 0;
  2123. struct termios *tp;
  2124. const char *othername = NULL;
  2126. if (*driver->refcount)
  2127. return -EBUSY;
  2129. for (p = tty_drivers; p; p = p->next) {
  2130. if (p == driver)
  2131. found++;
  2132. else if (p->major == driver->major)
  2133. othername = p->name;
  2134. }
  2136. if (!found)
  2137. return -ENOENT;
  2139. if (othername == NULL) {
  2140. retval = devfs_unregister_chrdev(driver->major, driver->name);
  2141. if (retval)
  2142. return retval;
  2143. } else
  2144. devfs_register_chrdev(driver->major, othername, &tty_fops);
  2146. if (driver->prev)
  2147. driver->prev->next = driver->next;
  2148. else
  2149. tty_drivers = driver->next;
  2151. if (driver->next)
  2152. driver->next->prev = driver->prev;
  2154. /*
  2155.  * Free the termios and termios_locked structures because
  2156.  * we don't want to get memory leaks when modular tty
  2157.  * drivers are removed from the kernel.
  2158.  */
  2159. for (i = 0; i < driver->num; i++) {
  2160. tp = driver->termios[i];
  2161. if (tp) {
  2162. driver->termios[i] = NULL;
  2163. kfree(tp);
  2164. }
  2165. tp = driver->termios_locked[i];
  2166. if (tp) {
  2167. driver->termios_locked[i] = NULL;
  2168. kfree(tp);
  2169. }
  2170. tty_unregister_devfs(driver, driver->minor_start + i);
  2171. }
  2172. proc_tty_unregister_driver(driver);
  2173. return 0;
  2174. }
  2177. /*
  2178.  * Initialize the console device. This is called *early*, so
  2179.  * we can't necessarily depend on lots of kernel help here.
  2180.  * Just do some early initializations, and do the complex setup
  2181.  * later.
  2182.  */
  2183. void __init console_init(void)
  2184. {
  2185. /* Setup the default TTY line discipline. */
  2186. memset(ldiscs, 0, sizeof(ldiscs));
  2187. (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
  2189. /*
  2190.  * Set up the standard termios.  Individual tty drivers may 
  2191.  * deviate from this; this is used as a template.
  2192.  */
  2193. memset(&tty_std_termios, 0, sizeof(struct termios));
  2194. memcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
  2195. tty_std_termios.c_iflag = ICRNL | IXON;
  2196. tty_std_termios.c_oflag = OPOST | ONLCR;
  2197. tty_std_termios.c_cflag = B38400 | CS8 | CREAD | HUPCL;
  2198. tty_std_termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
  2199. ECHOCTL | ECHOKE | IEXTEN;
  2201. /*
  2202.  * set up the console device so that later boot sequences can 
  2203.  * inform about problems etc..
  2204.  */
  2205. #ifdef CONFIG_EARLY_PRINTK
  2206. disable_early_printk(); 
  2207. #endif
  2208. #ifdef CONFIG_VT
  2209. con_init();
  2210. #endif
  2211. #ifdef CONFIG_AU1000_SERIAL_CONSOLE
  2212. au1000_serial_console_init();
  2213. #endif
  2214. #ifdef CONFIG_SERIAL_CONSOLE
  2215. #if (defined(CONFIG_8xx) || defined(CONFIG_8260))
  2216. console_8xx_init();
  2217. #elif defined(CONFIG_MAC_SERIAL) && defined(CONFIG_SERIAL)
  2218. if (_machine == _MACH_Pmac)
  2219.   mac_scc_console_init();
  2220. else
  2221. serial_console_init();
  2222. #elif defined(CONFIG_MAC_SERIAL)
  2223.   mac_scc_console_init();
  2224. #elif defined(CONFIG_PARISC)
  2225. pdc_console_init();
  2226. #elif defined(CONFIG_SERIAL)
  2227. serial_console_init();
  2228. #endif /* CONFIG_8xx */
  2229. #ifdef CONFIG_SGI_SERIAL
  2230. sgi_serial_console_init();
  2231. #endif
  2232. #if defined(CONFIG_MVME162_SCC) || defined(CONFIG_BVME6000_SCC) || defined(CONFIG_MVME147_SCC)
  2233. vme_scc_console_init();
  2234. #endif
  2235. #if defined(CONFIG_SERIAL167)
  2236. serial167_console_init();
  2237. #endif
  2238. #if defined(CONFIG_SH_SCI)
  2239. sci_console_init();
  2240. #endif
  2241. #endif
  2242. #ifdef CONFIG_TN3270_CONSOLE
  2243. tub3270_con_init();
  2244. #endif
  2245. #ifdef CONFIG_TN3215
  2246. con3215_init();
  2247. #endif
  2248. #ifdef CONFIG_HWC
  2249.         hwc_console_init();
  2250. #endif
  2251. #ifdef CONFIG_STDIO_CONSOLE
  2252. stdio_console_init();
  2253. #endif
  2254. #ifdef CONFIG_SERIAL_21285_CONSOLE
  2255. rs285_console_init();
  2256. #endif
  2257. #ifdef CONFIG_SERIAL_SA1100_CONSOLE
  2258. sa1100_rs_console_init();
  2259. #endif
  2260. #ifdef CONFIG_ARC_CONSOLE
  2261. arc_console_init();
  2262. #endif
  2263. #ifdef CONFIG_SERIAL_AMBA_CONSOLE
  2264. ambauart_console_init();
  2265. #endif
  2266. #ifdef CONFIG_SERIAL_TX3912_CONSOLE
  2267. tx3912_console_init();
  2268. #endif
  2269. #ifdef CONFIG_TXX927_SERIAL_CONSOLE
  2270. txx927_console_init();
  2271. #endif
  2272. #ifdef CONFIG_SIBYTE_SB1250_DUART_CONSOLE
  2273. sb1250_serial_console_init();
  2274. #endif
  2275. }
  2277. static struct tty_driver dev_tty_driver, dev_syscons_driver;
  2278. #ifdef CONFIG_UNIX98_PTYS
  2279. static struct tty_driver dev_ptmx_driver;
  2280. #endif
  2281. #ifdef CONFIG_VT
  2282. static struct tty_driver dev_console_driver;
  2283. #endif
  2285. /*
  2286.  * Ok, now we can initialize the rest of the tty devices and can count
  2287.  * on memory allocations, interrupts etc..
  2288.  */
  2289. void __init tty_init(void)
  2290. {
  2291. /*
  2292.  * dev_tty_driver and dev_console_driver are actually magic
  2293.  * devices which get redirected at open time.  Nevertheless,
  2294.  * we register them so that register_chrdev is called
  2295.  * appropriately.
  2296.  */
  2297. memset(&dev_tty_driver, 0, sizeof(struct tty_driver));
  2298. dev_tty_driver.magic = TTY_DRIVER_MAGIC;
  2299. dev_tty_driver.driver_name = "/dev/tty";
  2300. dev_tty_driver.name = dev_tty_driver.driver_name + 5;
  2301. dev_tty_driver.name_base = 0;
  2302. dev_tty_driver.major = TTYAUX_MAJOR;
  2303. dev_tty_driver.minor_start = 0;
  2304. dev_tty_driver.num = 1;
  2305. dev_tty_driver.type = TTY_DRIVER_TYPE_SYSTEM;
  2306. dev_tty_driver.subtype = SYSTEM_TYPE_TTY;
  2308. if (tty_register_driver(&dev_tty_driver))
  2309. panic("Couldn't register /dev/tty drivern");
  2311. dev_syscons_driver = dev_tty_driver;
  2312. dev_syscons_driver.driver_name = "/dev/console";
  2313. dev_syscons_driver.name = dev_syscons_driver.driver_name + 5;
  2314. dev_syscons_driver.major = TTYAUX_MAJOR;
  2315. dev_syscons_driver.minor_start = 1;
  2316. dev_syscons_driver.type = TTY_DRIVER_TYPE_SYSTEM;
  2317. dev_syscons_driver.subtype = SYSTEM_TYPE_SYSCONS;
  2319. if (tty_register_driver(&dev_syscons_driver))
  2320. panic("Couldn't register /dev/console drivern");
  2322. /* console calls tty_register_driver() before kmalloc() works.
  2323.  * Thus, we can't devfs_register() then.  Do so now, instead. 
  2324.  */
  2325. #ifdef CONFIG_VT
  2326. con_init_devfs();
  2327. #endif
  2329. #ifdef CONFIG_UNIX98_PTYS
  2330. dev_ptmx_driver = dev_tty_driver;
  2331. dev_ptmx_driver.driver_name = "/dev/ptmx";
  2332. dev_ptmx_driver.name = dev_ptmx_driver.driver_name + 5;
  2333. dev_ptmx_driver.major= MAJOR(PTMX_DEV);
  2334. dev_ptmx_driver.minor_start = MINOR(PTMX_DEV);
  2335. dev_ptmx_driver.type = TTY_DRIVER_TYPE_SYSTEM;
  2336. dev_ptmx_driver.subtype = SYSTEM_TYPE_SYSPTMX;
  2338. if (tty_register_driver(&dev_ptmx_driver))
  2339. panic("Couldn't register /dev/ptmx drivern");
  2340. #endif
  2342. #ifdef CONFIG_VT
  2343. dev_console_driver = dev_tty_driver;
  2344. dev_console_driver.driver_name = "/dev/vc/0";
  2345. dev_console_driver.name = dev_console_driver.driver_name + 5;
  2346. dev_console_driver.major = TTY_MAJOR;
  2347. dev_console_driver.type = TTY_DRIVER_TYPE_SYSTEM;
  2348. dev_console_driver.subtype = SYSTEM_TYPE_CONSOLE;
  2350. if (tty_register_driver(&dev_console_driver))
  2351. panic("Couldn't register /dev/tty0 drivern");
  2353. kbd_init();
  2354. #endif
  2356. #ifdef CONFIG_ESPSERIAL  /* init ESP before rs, so rs doesn't see the port */
  2357. espserial_init();
  2358. #endif
  2359. #if defined(CONFIG_MVME162_SCC) || defined(CONFIG_BVME6000_SCC) || defined(CONFIG_MVME147_SCC)
  2360. vme_scc_init();
  2361. #endif
  2362. #ifdef CONFIG_SERIAL_TX3912
  2363. tx3912_rs_init();
  2364. #endif
  2365. #ifdef CONFIG_ROCKETPORT
  2366. rp_init();
  2367. #endif
  2368. #ifdef CONFIG_SERIAL167
  2369. serial167_init();
  2370. #endif
  2371. #ifdef CONFIG_CYCLADES
  2372. cy_init();
  2373. #endif
  2374. #ifdef CONFIG_STALLION
  2375. stl_init();
  2376. #endif
  2377. #ifdef CONFIG_ISTALLION
  2378. stli_init();
  2379. #endif
  2380. #ifdef CONFIG_DIGI
  2381. pcxe_init();
  2382. #endif
  2383. #ifdef CONFIG_DIGIEPCA
  2384. pc_init();
  2385. #endif
  2386. #ifdef CONFIG_SPECIALIX
  2387. specialix_init();
  2388. #endif
  2389. #if (defined(CONFIG_8xx) || defined(CONFIG_8260))
  2390. rs_8xx_init();
  2391. #endif /* CONFIG_8xx */
  2392. pty_init();
  2393. #ifdef CONFIG_MOXA_SMARTIO
  2394. mxser_init();
  2395. #endif
  2396. #ifdef CONFIG_MOXA_INTELLIO
  2397. moxa_init();
  2398. #endif
  2399. #ifdef CONFIG_VT
  2400. vcs_init();
  2401. #endif
  2402. #ifdef CONFIG_TN3270
  2403. tub3270_init();
  2404. #endif
  2405. #ifdef CONFIG_TN3215
  2406. tty3215_init();
  2407. #endif
  2408. #ifdef CONFIG_HWC
  2409. hwc_tty_init();
  2410. #endif
  2411. #ifdef CONFIG_A2232
  2412. a2232board_init();
  2413. #endif
  2414. }