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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
tty_io.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：60k
源码类别：

嵌入式Linux

开发平台：

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