aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorAlan Cox <alan@redhat.com>2008-07-22 06:16:55 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2008-07-22 16:03:27 -0400
commit01e1abb2c27e43339b8829a2e3b1c6f53806b77a (patch)
tree9020ed77e480731af30061e3e6072a75a7266f7c /drivers
parentd76f2f4462bbb2cf7bc83a35c5278177aa627e89 (diff)
tty: Split ldisc code into its own file
Signed-off-by: Alan Cox <alan@redhat.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/char/Makefile2
-rw-r--r--drivers/char/tty_io.c636
-rw-r--r--drivers/char/tty_ldisc.c714
3 files changed, 724 insertions, 628 deletions
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 0e0d12a06462..dc5a327d72d5 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -7,7 +7,7 @@
7# 7#
8FONTMAPFILE = cp437.uni 8FONTMAPFILE = cp437.uni
9 9
10obj-y += mem.o random.o tty_io.o n_tty.o tty_ioctl.o 10obj-y += mem.o random.o tty_io.o n_tty.o tty_ioctl.o tty_ldisc.o
11 11
12obj-$(CONFIG_LEGACY_PTYS) += pty.o 12obj-$(CONFIG_LEGACY_PTYS) += pty.o
13obj-$(CONFIG_UNIX98_PTYS) += pty.o 13obj-$(CONFIG_UNIX98_PTYS) += pty.o
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 82f6a8c86332..d27a08b374d0 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -656,558 +656,6 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
656 656
657 657
658/** 658/**
659 * tty_set_termios_ldisc - set ldisc field
660 * @tty: tty structure
661 * @num: line discipline number
662 *
663 * This is probably overkill for real world processors but
664 * they are not on hot paths so a little discipline won't do
665 * any harm.
666 *
667 * Locking: takes termios_mutex
668 */
669
670static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
671{
672 mutex_lock(&tty->termios_mutex);
673 tty->termios->c_line = num;
674 mutex_unlock(&tty->termios_mutex);
675}
676
677/*
678 * This guards the refcounted line discipline lists. The lock
679 * must be taken with irqs off because there are hangup path
680 * callers who will do ldisc lookups and cannot sleep.
681 */
682
683static DEFINE_SPINLOCK(tty_ldisc_lock);
684static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
685/* Line disc dispatch table */
686static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
687
688/**
689 * tty_register_ldisc - install a line discipline
690 * @disc: ldisc number
691 * @new_ldisc: pointer to the ldisc object
692 *
693 * Installs a new line discipline into the kernel. The discipline
694 * is set up as unreferenced and then made available to the kernel
695 * from this point onwards.
696 *
697 * Locking:
698 * takes tty_ldisc_lock to guard against ldisc races
699 */
700
701int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
702{
703 unsigned long flags;
704 int ret = 0;
705
706 if (disc < N_TTY || disc >= NR_LDISCS)
707 return -EINVAL;
708
709 spin_lock_irqsave(&tty_ldisc_lock, flags);
710 tty_ldiscs[disc] = new_ldisc;
711 new_ldisc->num = disc;
712 new_ldisc->refcount = 0;
713 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
714
715 return ret;
716}
717EXPORT_SYMBOL(tty_register_ldisc);
718
719/**
720 * tty_unregister_ldisc - unload a line discipline
721 * @disc: ldisc number
722 * @new_ldisc: pointer to the ldisc object
723 *
724 * Remove a line discipline from the kernel providing it is not
725 * currently in use.
726 *
727 * Locking:
728 * takes tty_ldisc_lock to guard against ldisc races
729 */
730
731int tty_unregister_ldisc(int disc)
732{
733 unsigned long flags;
734 int ret = 0;
735
736 if (disc < N_TTY || disc >= NR_LDISCS)
737 return -EINVAL;
738
739 spin_lock_irqsave(&tty_ldisc_lock, flags);
740 if (tty_ldiscs[disc]->refcount)
741 ret = -EBUSY;
742 else
743 tty_ldiscs[disc] = NULL;
744 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
745
746 return ret;
747}
748EXPORT_SYMBOL(tty_unregister_ldisc);
749
750
751/**
752 * tty_ldisc_try_get - try and reference an ldisc
753 * @disc: ldisc number
754 * @ld: tty ldisc structure to complete
755 *
756 * Attempt to open and lock a line discipline into place. Return
757 * the line discipline refcounted and assigned in ld. On an error
758 * report the error code back
759 */
760
761static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
762{
763 unsigned long flags;
764 struct tty_ldisc_ops *ldops;
765 int err = -EINVAL;
766
767 spin_lock_irqsave(&tty_ldisc_lock, flags);
768 ld->ops = NULL;
769 ldops = tty_ldiscs[disc];
770 /* Check the entry is defined */
771 if (ldops) {
772 /* If the module is being unloaded we can't use it */
773 if (!try_module_get(ldops->owner))
774 err = -EAGAIN;
775 else {
776 /* lock it */
777 ldops->refcount++;
778 ld->ops = ldops;
779 err = 0;
780 }
781 }
782 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
783 return err;
784}
785
786/**
787 * tty_ldisc_get - take a reference to an ldisc
788 * @disc: ldisc number
789 * @ld: tty line discipline structure to use
790 *
791 * Takes a reference to a line discipline. Deals with refcounts and
792 * module locking counts. Returns NULL if the discipline is not available.
793 * Returns a pointer to the discipline and bumps the ref count if it is
794 * available
795 *
796 * Locking:
797 * takes tty_ldisc_lock to guard against ldisc races
798 */
799
800static int tty_ldisc_get(int disc, struct tty_ldisc *ld)
801{
802 int err;
803
804 if (disc < N_TTY || disc >= NR_LDISCS)
805 return -EINVAL;
806 err = tty_ldisc_try_get(disc, ld);
807 if (err == -EAGAIN) {
808 request_module("tty-ldisc-%d", disc);
809 err = tty_ldisc_try_get(disc, ld);
810 }
811 return err;
812}
813
814/**
815 * tty_ldisc_put - drop ldisc reference
816 * @disc: ldisc number
817 *
818 * Drop a reference to a line discipline. Manage refcounts and
819 * module usage counts
820 *
821 * Locking:
822 * takes tty_ldisc_lock to guard against ldisc races
823 */
824
825static void tty_ldisc_put(struct tty_ldisc_ops *ld)
826{
827 unsigned long flags;
828 int disc = ld->num;
829
830 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
831
832 spin_lock_irqsave(&tty_ldisc_lock, flags);
833 ld = tty_ldiscs[disc];
834 BUG_ON(ld->refcount == 0);
835 ld->refcount--;
836 module_put(ld->owner);
837 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
838}
839
840static void * tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
841{
842 return (*pos < NR_LDISCS) ? pos : NULL;
843}
844
845static void * tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
846{
847 (*pos)++;
848 return (*pos < NR_LDISCS) ? pos : NULL;
849}
850
851static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
852{
853}
854
855static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
856{
857 int i = *(loff_t *)v;
858 struct tty_ldisc ld;
859
860 if (tty_ldisc_get(i, &ld) < 0)
861 return 0;
862 seq_printf(m, "%-10s %2d\n", ld.ops->name ? ld.ops->name : "???", i);
863 tty_ldisc_put(ld.ops);
864 return 0;
865}
866
867static const struct seq_operations tty_ldiscs_seq_ops = {
868 .start = tty_ldiscs_seq_start,
869 .next = tty_ldiscs_seq_next,
870 .stop = tty_ldiscs_seq_stop,
871 .show = tty_ldiscs_seq_show,
872};
873
874static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
875{
876 return seq_open(file, &tty_ldiscs_seq_ops);
877}
878
879const struct file_operations tty_ldiscs_proc_fops = {
880 .owner = THIS_MODULE,
881 .open = proc_tty_ldiscs_open,
882 .read = seq_read,
883 .llseek = seq_lseek,
884 .release = seq_release,
885};
886
887/**
888 * tty_ldisc_assign - set ldisc on a tty
889 * @tty: tty to assign
890 * @ld: line discipline
891 *
892 * Install an instance of a line discipline into a tty structure. The
893 * ldisc must have a reference count above zero to ensure it remains/
894 * The tty instance refcount starts at zero.
895 *
896 * Locking:
897 * Caller must hold references
898 */
899
900static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
901{
902 ld->refcount = 0;
903 tty->ldisc = *ld;
904}
905
906/**
907 * tty_ldisc_try - internal helper
908 * @tty: the tty
909 *
910 * Make a single attempt to grab and bump the refcount on
911 * the tty ldisc. Return 0 on failure or 1 on success. This is
912 * used to implement both the waiting and non waiting versions
913 * of tty_ldisc_ref
914 *
915 * Locking: takes tty_ldisc_lock
916 */
917
918static int tty_ldisc_try(struct tty_struct *tty)
919{
920 unsigned long flags;
921 struct tty_ldisc *ld;
922 int ret = 0;
923
924 spin_lock_irqsave(&tty_ldisc_lock, flags);
925 ld = &tty->ldisc;
926 if (test_bit(TTY_LDISC, &tty->flags)) {
927 ld->refcount++;
928 ret = 1;
929 }
930 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
931 return ret;
932}
933
934/**
935 * tty_ldisc_ref_wait - wait for the tty ldisc
936 * @tty: tty device
937 *
938 * Dereference the line discipline for the terminal and take a
939 * reference to it. If the line discipline is in flux then
940 * wait patiently until it changes.
941 *
942 * Note: Must not be called from an IRQ/timer context. The caller
943 * must also be careful not to hold other locks that will deadlock
944 * against a discipline change, such as an existing ldisc reference
945 * (which we check for)
946 *
947 * Locking: call functions take tty_ldisc_lock
948 */
949
950struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
951{
952 /* wait_event is a macro */
953 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
954 if (tty->ldisc.refcount == 0)
955 printk(KERN_ERR "tty_ldisc_ref_wait\n");
956 return &tty->ldisc;
957}
958
959EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
960
961/**
962 * tty_ldisc_ref - get the tty ldisc
963 * @tty: tty device
964 *
965 * Dereference the line discipline for the terminal and take a
966 * reference to it. If the line discipline is in flux then
967 * return NULL. Can be called from IRQ and timer functions.
968 *
969 * Locking: called functions take tty_ldisc_lock
970 */
971
972struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
973{
974 if (tty_ldisc_try(tty))
975 return &tty->ldisc;
976 return NULL;
977}
978
979EXPORT_SYMBOL_GPL(tty_ldisc_ref);
980
981/**
982 * tty_ldisc_deref - free a tty ldisc reference
983 * @ld: reference to free up
984 *
985 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
986 * be called in IRQ context.
987 *
988 * Locking: takes tty_ldisc_lock
989 */
990
991void tty_ldisc_deref(struct tty_ldisc *ld)
992{
993 unsigned long flags;
994
995 BUG_ON(ld == NULL);
996
997 spin_lock_irqsave(&tty_ldisc_lock, flags);
998 if (ld->refcount == 0)
999 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
1000 else
1001 ld->refcount--;
1002 if (ld->refcount == 0)
1003 wake_up(&tty_ldisc_wait);
1004 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1005}
1006
1007EXPORT_SYMBOL_GPL(tty_ldisc_deref);
1008
1009/**
1010 * tty_ldisc_enable - allow ldisc use
1011 * @tty: terminal to activate ldisc on
1012 *
1013 * Set the TTY_LDISC flag when the line discipline can be called
1014 * again. Do necessary wakeups for existing sleepers.
1015 *
1016 * Note: nobody should set this bit except via this function. Clearing
1017 * directly is allowed.
1018 */
1019
1020static void tty_ldisc_enable(struct tty_struct *tty)
1021{
1022 set_bit(TTY_LDISC, &tty->flags);
1023 wake_up(&tty_ldisc_wait);
1024}
1025
1026/**
1027 * tty_ldisc_restore - helper for tty ldisc change
1028 * @tty: tty to recover
1029 * @old: previous ldisc
1030 *
1031 * Restore the previous line discipline or N_TTY when a line discipline
1032 * change fails due to an open error
1033 */
1034
1035static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
1036{
1037 char buf[64];
1038 struct tty_ldisc new_ldisc;
1039
1040 /* There is an outstanding reference here so this is safe */
1041 tty_ldisc_get(old->ops->num, old);
1042 tty_ldisc_assign(tty, old);
1043 tty_set_termios_ldisc(tty, old->ops->num);
1044 if (old->ops->open && (old->ops->open(tty) < 0)) {
1045 tty_ldisc_put(old->ops);
1046 /* This driver is always present */
1047 if (tty_ldisc_get(N_TTY, &new_ldisc) < 0)
1048 panic("n_tty: get");
1049 tty_ldisc_assign(tty, &new_ldisc);
1050 tty_set_termios_ldisc(tty, N_TTY);
1051 if (new_ldisc.ops->open) {
1052 int r = new_ldisc.ops->open(tty);
1053 if (r < 0)
1054 panic("Couldn't open N_TTY ldisc for "
1055 "%s --- error %d.",
1056 tty_name(tty, buf), r);
1057 }
1058 }
1059}
1060
1061/**
1062 * tty_set_ldisc - set line discipline
1063 * @tty: the terminal to set
1064 * @ldisc: the line discipline
1065 *
1066 * Set the discipline of a tty line. Must be called from a process
1067 * context.
1068 *
1069 * Locking: takes tty_ldisc_lock.
1070 * called functions take termios_mutex
1071 */
1072
1073static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
1074{
1075 int retval;
1076 struct tty_ldisc o_ldisc, new_ldisc;
1077 int work;
1078 unsigned long flags;
1079 struct tty_struct *o_tty;
1080
1081restart:
1082 /* This is a bit ugly for now but means we can break the 'ldisc
1083 is part of the tty struct' assumption later */
1084 retval = tty_ldisc_get(ldisc, &new_ldisc);
1085 if (retval)
1086 return retval;
1087
1088 /*
1089 * Problem: What do we do if this blocks ?
1090 */
1091
1092 tty_wait_until_sent(tty, 0);
1093
1094 if (tty->ldisc.ops->num == ldisc) {
1095 tty_ldisc_put(new_ldisc.ops);
1096 return 0;
1097 }
1098
1099 /*
1100 * No more input please, we are switching. The new ldisc
1101 * will update this value in the ldisc open function
1102 */
1103
1104 tty->receive_room = 0;
1105
1106 o_ldisc = tty->ldisc;
1107 o_tty = tty->link;
1108
1109 /*
1110 * Make sure we don't change while someone holds a
1111 * reference to the line discipline. The TTY_LDISC bit
1112 * prevents anyone taking a reference once it is clear.
1113 * We need the lock to avoid racing reference takers.
1114 */
1115
1116 spin_lock_irqsave(&tty_ldisc_lock, flags);
1117 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
1118 if (tty->ldisc.refcount) {
1119 /* Free the new ldisc we grabbed. Must drop the lock
1120 first. */
1121 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1122 tty_ldisc_put(o_ldisc.ops);
1123 /*
1124 * There are several reasons we may be busy, including
1125 * random momentary I/O traffic. We must therefore
1126 * retry. We could distinguish between blocking ops
1127 * and retries if we made tty_ldisc_wait() smarter.
1128 * That is up for discussion.
1129 */
1130 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
1131 return -ERESTARTSYS;
1132 goto restart;
1133 }
1134 if (o_tty && o_tty->ldisc.refcount) {
1135 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1136 tty_ldisc_put(o_tty->ldisc.ops);
1137 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
1138 return -ERESTARTSYS;
1139 goto restart;
1140 }
1141 }
1142 /*
1143 * If the TTY_LDISC bit is set, then we are racing against
1144 * another ldisc change
1145 */
1146 if (!test_bit(TTY_LDISC, &tty->flags)) {
1147 struct tty_ldisc *ld;
1148 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1149 tty_ldisc_put(new_ldisc.ops);
1150 ld = tty_ldisc_ref_wait(tty);
1151 tty_ldisc_deref(ld);
1152 goto restart;
1153 }
1154
1155 clear_bit(TTY_LDISC, &tty->flags);
1156 if (o_tty)
1157 clear_bit(TTY_LDISC, &o_tty->flags);
1158 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1159
1160 /*
1161 * From this point on we know nobody has an ldisc
1162 * usage reference, nor can they obtain one until
1163 * we say so later on.
1164 */
1165
1166 work = cancel_delayed_work(&tty->buf.work);
1167 /*
1168 * Wait for ->hangup_work and ->buf.work handlers to terminate
1169 * MUST NOT hold locks here.
1170 */
1171 flush_scheduled_work();
1172 /* Shutdown the current discipline. */
1173 if (o_ldisc.ops->close)
1174 (o_ldisc.ops->close)(tty);
1175
1176 /* Now set up the new line discipline. */
1177 tty_ldisc_assign(tty, &new_ldisc);
1178 tty_set_termios_ldisc(tty, ldisc);
1179 if (new_ldisc.ops->open)
1180 retval = (new_ldisc.ops->open)(tty);
1181 if (retval < 0) {
1182 tty_ldisc_put(new_ldisc.ops);
1183 tty_ldisc_restore(tty, &o_ldisc);
1184 }
1185 /* At this point we hold a reference to the new ldisc and a
1186 a reference to the old ldisc. If we ended up flipping back
1187 to the existing ldisc we have two references to it */
1188
1189 if (tty->ldisc.ops->num != o_ldisc.ops->num && tty->ops->set_ldisc)
1190 tty->ops->set_ldisc(tty);
1191
1192 tty_ldisc_put(o_ldisc.ops);
1193
1194 /*
1195 * Allow ldisc referencing to occur as soon as the driver
1196 * ldisc callback completes.
1197 */
1198
1199 tty_ldisc_enable(tty);
1200 if (o_tty)
1201 tty_ldisc_enable(o_tty);
1202
1203 /* Restart it in case no characters kick it off. Safe if
1204 already running */
1205 if (work)
1206 schedule_delayed_work(&tty->buf.work, 1);
1207 return retval;
1208}
1209
1210/**
1211 * get_tty_driver - find device of a tty 659 * get_tty_driver - find device of a tty
1212 * @dev_t: device identifier 660 * @dev_t: device identifier
1213 * @index: returns the index of the tty 661 * @index: returns the index of the tty
@@ -2193,7 +1641,6 @@ static int init_dev(struct tty_driver *driver, int idx,
2193 struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc; 1641 struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
2194 struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc; 1642 struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
2195 int retval = 0; 1643 int retval = 0;
2196 struct tty_ldisc *ld;
2197 1644
2198 /* check whether we're reopening an existing tty */ 1645 /* check whether we're reopening an existing tty */
2199 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) { 1646 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
@@ -2342,25 +1789,12 @@ static int init_dev(struct tty_driver *driver, int idx,
2342 * If we fail here just call release_tty to clean up. No need 1789 * If we fail here just call release_tty to clean up. No need
2343 * to decrement the use counts, as release_tty doesn't care. 1790 * to decrement the use counts, as release_tty doesn't care.
2344 */ 1791 */
2345
2346 ld = &tty->ldisc;
2347 1792
2348 if (ld->ops->open) { 1793 retval = tty_ldisc_setup(tty, o_tty);
2349 retval = (ld->ops->open)(tty); 1794
2350 if (retval) 1795 if (retval)
2351 goto release_mem_out; 1796 goto release_mem_out;
2352 } 1797 goto success;
2353 if (o_tty && o_tty->ldisc.ops->open) {
2354 retval = (o_tty->ldisc.ops->open)(o_tty);
2355 if (retval) {
2356 if (ld->ops->close)
2357 (ld->ops->close)(tty);
2358 goto release_mem_out;
2359 }
2360 tty_ldisc_enable(o_tty);
2361 }
2362 tty_ldisc_enable(tty);
2363 goto success;
2364 1798
2365 /* 1799 /*
2366 * This fast open can be used if the tty is already open. 1800 * This fast open can be used if the tty is already open.
@@ -2498,12 +1932,10 @@ static void release_tty(struct tty_struct *tty, int idx)
2498static void release_dev(struct file *filp) 1932static void release_dev(struct file *filp)
2499{ 1933{
2500 struct tty_struct *tty, *o_tty; 1934 struct tty_struct *tty, *o_tty;
2501 struct tty_ldisc ld;
2502 int pty_master, tty_closing, o_tty_closing, do_sleep; 1935 int pty_master, tty_closing, o_tty_closing, do_sleep;
2503 int devpts; 1936 int devpts;
2504 int idx; 1937 int idx;
2505 char buf[64]; 1938 char buf[64];
2506 unsigned long flags;
2507 1939
2508 tty = (struct tty_struct *)filp->private_data; 1940 tty = (struct tty_struct *)filp->private_data;
2509 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, 1941 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode,
@@ -2705,56 +2137,9 @@ static void release_dev(struct file *filp)
2705 printk(KERN_DEBUG "freeing tty structure..."); 2137 printk(KERN_DEBUG "freeing tty structure...");
2706#endif 2138#endif
2707 /* 2139 /*
2708 * Prevent flush_to_ldisc() from rescheduling the work for later. Then 2140 * Ask the line discipline code to release its structures
2709 * kill any delayed work. As this is the final close it does not
2710 * race with the set_ldisc code path.
2711 */
2712 clear_bit(TTY_LDISC, &tty->flags);
2713 cancel_delayed_work(&tty->buf.work);
2714
2715 /*
2716 * Wait for ->hangup_work and ->buf.work handlers to terminate
2717 */
2718
2719 flush_scheduled_work();
2720
2721 /*
2722 * Wait for any short term users (we know they are just driver
2723 * side waiters as the file is closing so user count on the file
2724 * side is zero.
2725 */ 2141 */
2726 spin_lock_irqsave(&tty_ldisc_lock, flags); 2142 tty_ldisc_release(tty, o_tty);
2727 while (tty->ldisc.refcount) {
2728 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2729 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2730 spin_lock_irqsave(&tty_ldisc_lock, flags);
2731 }
2732 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2733 /*
2734 * Shutdown the current line discipline, and reset it to N_TTY.
2735 *
2736 * FIXME: this MUST get fixed for the new reflocking
2737 */
2738 if (tty->ldisc.ops->close)
2739 (tty->ldisc.ops->close)(tty);
2740 tty_ldisc_put(tty->ldisc.ops);
2741
2742 /*
2743 * Switch the line discipline back
2744 */
2745 WARN_ON(tty_ldisc_get(N_TTY, &ld));
2746 tty_ldisc_assign(tty, &ld);
2747 tty_set_termios_ldisc(tty, N_TTY);
2748 if (o_tty) {
2749 /* FIXME: could o_tty be in setldisc here ? */
2750 clear_bit(TTY_LDISC, &o_tty->flags);
2751 if (o_tty->ldisc.ops->close)
2752 (o_tty->ldisc.ops->close)(o_tty);
2753 tty_ldisc_put(o_tty->ldisc.ops);
2754 WARN_ON(tty_ldisc_get(N_TTY, &ld));
2755 tty_ldisc_assign(o_tty, &ld);
2756 tty_set_termios_ldisc(o_tty, N_TTY);
2757 }
2758 /* 2143 /*
2759 * The release_tty function takes care of the details of clearing 2144 * The release_tty function takes care of the details of clearing
2760 * the slots and preserving the termios structure. 2145 * the slots and preserving the termios structure.
@@ -3962,12 +3347,9 @@ EXPORT_SYMBOL(tty_flip_buffer_push);
3962 3347
3963static void initialize_tty_struct(struct tty_struct *tty) 3348static void initialize_tty_struct(struct tty_struct *tty)
3964{ 3349{
3965 struct tty_ldisc ld;
3966 memset(tty, 0, sizeof(struct tty_struct)); 3350 memset(tty, 0, sizeof(struct tty_struct));
3967 tty->magic = TTY_MAGIC; 3351 tty->magic = TTY_MAGIC;
3968 if (tty_ldisc_get(N_TTY, &ld) < 0) 3352 tty_ldisc_init(tty);
3969 panic("n_tty: init_tty");
3970 tty_ldisc_assign(tty, &ld);
3971 tty->session = NULL; 3353 tty->session = NULL;
3972 tty->pgrp = NULL; 3354 tty->pgrp = NULL;
3973 tty->overrun_time = jiffies; 3355 tty->overrun_time = jiffies;
@@ -4280,7 +3662,7 @@ void __init console_init(void)
4280 initcall_t *call; 3662 initcall_t *call;
4281 3663
4282 /* Setup the default TTY line discipline. */ 3664 /* Setup the default TTY line discipline. */
4283 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY); 3665 tty_ldisc_begin();
4284 3666
4285 /* 3667 /*
4286 * set up the console device so that later boot sequences can 3668 * set up the console device so that later boot sequences can
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
new file mode 100644
index 000000000000..241cbdea65ab
--- /dev/null
+++ b/drivers/char/tty_ldisc.c
@@ -0,0 +1,714 @@
1#include <linux/types.h>
2#include <linux/major.h>
3#include <linux/errno.h>
4#include <linux/signal.h>
5#include <linux/fcntl.h>
6#include <linux/sched.h>
7#include <linux/interrupt.h>
8#include <linux/tty.h>
9#include <linux/tty_driver.h>
10#include <linux/tty_flip.h>
11#include <linux/devpts_fs.h>
12#include <linux/file.h>
13#include <linux/fdtable.h>
14#include <linux/console.h>
15#include <linux/timer.h>
16#include <linux/ctype.h>
17#include <linux/kd.h>
18#include <linux/mm.h>
19#include <linux/string.h>
20#include <linux/slab.h>
21#include <linux/poll.h>
22#include <linux/proc_fs.h>
23#include <linux/init.h>
24#include <linux/module.h>
25#include <linux/smp_lock.h>
26#include <linux/device.h>
27#include <linux/wait.h>
28#include <linux/bitops.h>
29#include <linux/delay.h>
30#include <linux/seq_file.h>
31
32#include <linux/uaccess.h>
33#include <asm/system.h>
34
35#include <linux/kbd_kern.h>
36#include <linux/vt_kern.h>
37#include <linux/selection.h>
38
39#include <linux/kmod.h>
40#include <linux/nsproxy.h>
41
42/*
43 * This guards the refcounted line discipline lists. The lock
44 * must be taken with irqs off because there are hangup path
45 * callers who will do ldisc lookups and cannot sleep.
46 */
47
48static DEFINE_SPINLOCK(tty_ldisc_lock);
49static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
50/* Line disc dispatch table */
51static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
52
53/**
54 * tty_register_ldisc - install a line discipline
55 * @disc: ldisc number
56 * @new_ldisc: pointer to the ldisc object
57 *
58 * Installs a new line discipline into the kernel. The discipline
59 * is set up as unreferenced and then made available to the kernel
60 * from this point onwards.
61 *
62 * Locking:
63 * takes tty_ldisc_lock to guard against ldisc races
64 */
65
66int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
67{
68 unsigned long flags;
69 int ret = 0;
70
71 if (disc < N_TTY || disc >= NR_LDISCS)
72 return -EINVAL;
73
74 spin_lock_irqsave(&tty_ldisc_lock, flags);
75 tty_ldiscs[disc] = new_ldisc;
76 new_ldisc->num = disc;
77 new_ldisc->refcount = 0;
78 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
79
80 return ret;
81}
82EXPORT_SYMBOL(tty_register_ldisc);
83
84/**
85 * tty_unregister_ldisc - unload a line discipline
86 * @disc: ldisc number
87 * @new_ldisc: pointer to the ldisc object
88 *
89 * Remove a line discipline from the kernel providing it is not
90 * currently in use.
91 *
92 * Locking:
93 * takes tty_ldisc_lock to guard against ldisc races
94 */
95
96int tty_unregister_ldisc(int disc)
97{
98 unsigned long flags;
99 int ret = 0;
100
101 if (disc < N_TTY || disc >= NR_LDISCS)
102 return -EINVAL;
103
104 spin_lock_irqsave(&tty_ldisc_lock, flags);
105 if (tty_ldiscs[disc]->refcount)
106 ret = -EBUSY;
107 else
108 tty_ldiscs[disc] = NULL;
109 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
110
111 return ret;
112}
113EXPORT_SYMBOL(tty_unregister_ldisc);
114
115
116/**
117 * tty_ldisc_try_get - try and reference an ldisc
118 * @disc: ldisc number
119 * @ld: tty ldisc structure to complete
120 *
121 * Attempt to open and lock a line discipline into place. Return
122 * the line discipline refcounted and assigned in ld. On an error
123 * report the error code back
124 */
125
126static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
127{
128 unsigned long flags;
129 struct tty_ldisc_ops *ldops;
130 int err = -EINVAL;
131
132 spin_lock_irqsave(&tty_ldisc_lock, flags);
133 ld->ops = NULL;
134 ldops = tty_ldiscs[disc];
135 /* Check the entry is defined */
136 if (ldops) {
137 /* If the module is being unloaded we can't use it */
138 if (!try_module_get(ldops->owner))
139 err = -EAGAIN;
140 else {
141 /* lock it */
142 ldops->refcount++;
143 ld->ops = ldops;
144 err = 0;
145 }
146 }
147 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
148 return err;
149}
150
151/**
152 * tty_ldisc_get - take a reference to an ldisc
153 * @disc: ldisc number
154 * @ld: tty line discipline structure to use
155 *
156 * Takes a reference to a line discipline. Deals with refcounts and
157 * module locking counts. Returns NULL if the discipline is not available.
158 * Returns a pointer to the discipline and bumps the ref count if it is
159 * available
160 *
161 * Locking:
162 * takes tty_ldisc_lock to guard against ldisc races
163 */
164
165static int tty_ldisc_get(int disc, struct tty_ldisc *ld)
166{
167 int err;
168
169 if (disc < N_TTY || disc >= NR_LDISCS)
170 return -EINVAL;
171 err = tty_ldisc_try_get(disc, ld);
172 if (err == -EAGAIN) {
173 request_module("tty-ldisc-%d", disc);
174 err = tty_ldisc_try_get(disc, ld);
175 }
176 return err;
177}
178
179/**
180 * tty_ldisc_put - drop ldisc reference
181 * @disc: ldisc number
182 *
183 * Drop a reference to a line discipline. Manage refcounts and
184 * module usage counts
185 *
186 * Locking:
187 * takes tty_ldisc_lock to guard against ldisc races
188 */
189
190static void tty_ldisc_put(struct tty_ldisc_ops *ld)
191{
192 unsigned long flags;
193 int disc = ld->num;
194
195 BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
196
197 spin_lock_irqsave(&tty_ldisc_lock, flags);
198 ld = tty_ldiscs[disc];
199 BUG_ON(ld->refcount == 0);
200 ld->refcount--;
201 module_put(ld->owner);
202 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
203}
204
205static void * tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
206{
207 return (*pos < NR_LDISCS) ? pos : NULL;
208}
209
210static void * tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
211{
212 (*pos)++;
213 return (*pos < NR_LDISCS) ? pos : NULL;
214}
215
216static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
217{
218}
219
220static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
221{
222 int i = *(loff_t *)v;
223 struct tty_ldisc ld;
224
225 if (tty_ldisc_get(i, &ld) < 0)
226 return 0;
227 seq_printf(m, "%-10s %2d\n", ld.ops->name ? ld.ops->name : "???", i);
228 tty_ldisc_put(ld.ops);
229 return 0;
230}
231
232static const struct seq_operations tty_ldiscs_seq_ops = {
233 .start = tty_ldiscs_seq_start,
234 .next = tty_ldiscs_seq_next,
235 .stop = tty_ldiscs_seq_stop,
236 .show = tty_ldiscs_seq_show,
237};
238
239static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
240{
241 return seq_open(file, &tty_ldiscs_seq_ops);
242}
243
244const struct file_operations tty_ldiscs_proc_fops = {
245 .owner = THIS_MODULE,
246 .open = proc_tty_ldiscs_open,
247 .read = seq_read,
248 .llseek = seq_lseek,
249 .release = seq_release,
250};
251
252/**
253 * tty_ldisc_assign - set ldisc on a tty
254 * @tty: tty to assign
255 * @ld: line discipline
256 *
257 * Install an instance of a line discipline into a tty structure. The
258 * ldisc must have a reference count above zero to ensure it remains/
259 * The tty instance refcount starts at zero.
260 *
261 * Locking:
262 * Caller must hold references
263 */
264
265static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
266{
267 ld->refcount = 0;
268 tty->ldisc = *ld;
269}
270
271/**
272 * tty_ldisc_try - internal helper
273 * @tty: the tty
274 *
275 * Make a single attempt to grab and bump the refcount on
276 * the tty ldisc. Return 0 on failure or 1 on success. This is
277 * used to implement both the waiting and non waiting versions
278 * of tty_ldisc_ref
279 *
280 * Locking: takes tty_ldisc_lock
281 */
282
283static int tty_ldisc_try(struct tty_struct *tty)
284{
285 unsigned long flags;
286 struct tty_ldisc *ld;
287 int ret = 0;
288
289 spin_lock_irqsave(&tty_ldisc_lock, flags);
290 ld = &tty->ldisc;
291 if (test_bit(TTY_LDISC, &tty->flags)) {
292 ld->refcount++;
293 ret = 1;
294 }
295 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
296 return ret;
297}
298
299/**
300 * tty_ldisc_ref_wait - wait for the tty ldisc
301 * @tty: tty device
302 *
303 * Dereference the line discipline for the terminal and take a
304 * reference to it. If the line discipline is in flux then
305 * wait patiently until it changes.
306 *
307 * Note: Must not be called from an IRQ/timer context. The caller
308 * must also be careful not to hold other locks that will deadlock
309 * against a discipline change, such as an existing ldisc reference
310 * (which we check for)
311 *
312 * Locking: call functions take tty_ldisc_lock
313 */
314
315struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
316{
317 /* wait_event is a macro */
318 wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
319 if (tty->ldisc.refcount == 0)
320 printk(KERN_ERR "tty_ldisc_ref_wait\n");
321 return &tty->ldisc;
322}
323
324EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
325
326/**
327 * tty_ldisc_ref - get the tty ldisc
328 * @tty: tty device
329 *
330 * Dereference the line discipline for the terminal and take a
331 * reference to it. If the line discipline is in flux then
332 * return NULL. Can be called from IRQ and timer functions.
333 *
334 * Locking: called functions take tty_ldisc_lock
335 */
336
337struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
338{
339 if (tty_ldisc_try(tty))
340 return &tty->ldisc;
341 return NULL;
342}
343
344EXPORT_SYMBOL_GPL(tty_ldisc_ref);
345
346/**
347 * tty_ldisc_deref - free a tty ldisc reference
348 * @ld: reference to free up
349 *
350 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
351 * be called in IRQ context.
352 *
353 * Locking: takes tty_ldisc_lock
354 */
355
356void tty_ldisc_deref(struct tty_ldisc *ld)
357{
358 unsigned long flags;
359
360 BUG_ON(ld == NULL);
361
362 spin_lock_irqsave(&tty_ldisc_lock, flags);
363 if (ld->refcount == 0)
364 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
365 else
366 ld->refcount--;
367 if (ld->refcount == 0)
368 wake_up(&tty_ldisc_wait);
369 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
370}
371
372EXPORT_SYMBOL_GPL(tty_ldisc_deref);
373
374/**
375 * tty_ldisc_enable - allow ldisc use
376 * @tty: terminal to activate ldisc on
377 *
378 * Set the TTY_LDISC flag when the line discipline can be called
379 * again. Do necessary wakeups for existing sleepers.
380 *
381 * Note: nobody should set this bit except via this function. Clearing
382 * directly is allowed.
383 */
384
385void tty_ldisc_enable(struct tty_struct *tty)
386{
387 set_bit(TTY_LDISC, &tty->flags);
388 wake_up(&tty_ldisc_wait);
389}
390
391/**
392 * tty_set_termios_ldisc - set ldisc field
393 * @tty: tty structure
394 * @num: line discipline number
395 *
396 * This is probably overkill for real world processors but
397 * they are not on hot paths so a little discipline won't do
398 * any harm.
399 *
400 * Locking: takes termios_mutex
401 */
402
403static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
404{
405 mutex_lock(&tty->termios_mutex);
406 tty->termios->c_line = num;
407 mutex_unlock(&tty->termios_mutex);
408}
409
410
411/**
412 * tty_ldisc_restore - helper for tty ldisc change
413 * @tty: tty to recover
414 * @old: previous ldisc
415 *
416 * Restore the previous line discipline or N_TTY when a line discipline
417 * change fails due to an open error
418 */
419
420static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
421{
422 char buf[64];
423 struct tty_ldisc new_ldisc;
424
425 /* There is an outstanding reference here so this is safe */
426 tty_ldisc_get(old->ops->num, old);
427 tty_ldisc_assign(tty, old);
428 tty_set_termios_ldisc(tty, old->ops->num);
429 if (old->ops->open && (old->ops->open(tty) < 0)) {
430 tty_ldisc_put(old->ops);
431 /* This driver is always present */
432 if (tty_ldisc_get(N_TTY, &new_ldisc) < 0)
433 panic("n_tty: get");
434 tty_ldisc_assign(tty, &new_ldisc);
435 tty_set_termios_ldisc(tty, N_TTY);
436 if (new_ldisc.ops->open) {
437 int r = new_ldisc.ops->open(tty);
438 if (r < 0)
439 panic("Couldn't open N_TTY ldisc for "
440 "%s --- error %d.",
441 tty_name(tty, buf), r);
442 }
443 }
444}
445
446/**
447 * tty_set_ldisc - set line discipline
448 * @tty: the terminal to set
449 * @ldisc: the line discipline
450 *
451 * Set the discipline of a tty line. Must be called from a process
452 * context.
453 *
454 * Locking: takes tty_ldisc_lock.
455 * called functions take termios_mutex
456 */
457
458int tty_set_ldisc(struct tty_struct *tty, int ldisc)
459{
460 int retval;
461 struct tty_ldisc o_ldisc, new_ldisc;
462 int work;
463 unsigned long flags;
464 struct tty_struct *o_tty;
465
466restart:
467 /* This is a bit ugly for now but means we can break the 'ldisc
468 is part of the tty struct' assumption later */
469 retval = tty_ldisc_get(ldisc, &new_ldisc);
470 if (retval)
471 return retval;
472
473 /*
474 * Problem: What do we do if this blocks ?
475 */
476
477 tty_wait_until_sent(tty, 0);
478
479 if (tty->ldisc.ops->num == ldisc) {
480 tty_ldisc_put(new_ldisc.ops);
481 return 0;
482 }
483
484 /*
485 * No more input please, we are switching. The new ldisc
486 * will update this value in the ldisc open function
487 */
488
489 tty->receive_room = 0;
490
491 o_ldisc = tty->ldisc;
492 o_tty = tty->link;
493
494 /*
495 * Make sure we don't change while someone holds a
496 * reference to the line discipline. The TTY_LDISC bit
497 * prevents anyone taking a reference once it is clear.
498 * We need the lock to avoid racing reference takers.
499 */
500
501 spin_lock_irqsave(&tty_ldisc_lock, flags);
502 if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
503 if (tty->ldisc.refcount) {
504 /* Free the new ldisc we grabbed. Must drop the lock
505 first. */
506 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
507 tty_ldisc_put(o_ldisc.ops);
508 /*
509 * There are several reasons we may be busy, including
510 * random momentary I/O traffic. We must therefore
511 * retry. We could distinguish between blocking ops
512 * and retries if we made tty_ldisc_wait() smarter.
513 * That is up for discussion.
514 */
515 if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
516 return -ERESTARTSYS;
517 goto restart;
518 }
519 if (o_tty && o_tty->ldisc.refcount) {
520 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
521 tty_ldisc_put(o_tty->ldisc.ops);
522 if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
523 return -ERESTARTSYS;
524 goto restart;
525 }
526 }
527 /*
528 * If the TTY_LDISC bit is set, then we are racing against
529 * another ldisc change
530 */
531 if (!test_bit(TTY_LDISC, &tty->flags)) {
532 struct tty_ldisc *ld;
533 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
534 tty_ldisc_put(new_ldisc.ops);
535 ld = tty_ldisc_ref_wait(tty);
536 tty_ldisc_deref(ld);
537 goto restart;
538 }
539
540 clear_bit(TTY_LDISC, &tty->flags);
541 if (o_tty)
542 clear_bit(TTY_LDISC, &o_tty->flags);
543 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
544
545 /*
546 * From this point on we know nobody has an ldisc
547 * usage reference, nor can they obtain one until
548 * we say so later on.
549 */
550
551 work = cancel_delayed_work(&tty->buf.work);
552 /*
553 * Wait for ->hangup_work and ->buf.work handlers to terminate
554 * MUST NOT hold locks here.
555 */
556 flush_scheduled_work();
557 /* Shutdown the current discipline. */
558 if (o_ldisc.ops->close)
559 (o_ldisc.ops->close)(tty);
560
561 /* Now set up the new line discipline. */
562 tty_ldisc_assign(tty, &new_ldisc);
563 tty_set_termios_ldisc(tty, ldisc);
564 if (new_ldisc.ops->open)
565 retval = (new_ldisc.ops->open)(tty);
566 if (retval < 0) {
567 tty_ldisc_put(new_ldisc.ops);
568 tty_ldisc_restore(tty, &o_ldisc);
569 }
570 /* At this point we hold a reference to the new ldisc and a
571 a reference to the old ldisc. If we ended up flipping back
572 to the existing ldisc we have two references to it */
573
574 if (tty->ldisc.ops->num != o_ldisc.ops->num && tty->ops->set_ldisc)
575 tty->ops->set_ldisc(tty);
576
577 tty_ldisc_put(o_ldisc.ops);
578
579 /*
580 * Allow ldisc referencing to occur as soon as the driver
581 * ldisc callback completes.
582 */
583
584 tty_ldisc_enable(tty);
585 if (o_tty)
586 tty_ldisc_enable(o_tty);
587
588 /* Restart it in case no characters kick it off. Safe if
589 already running */
590 if (work)
591 schedule_delayed_work(&tty->buf.work, 1);
592 return retval;
593}
594
595
596/**
597 * tty_ldisc_setup - open line discipline
598 * @tty: tty being shut down
599 * @o_tty: pair tty for pty/tty pairs
600 *
601 * Called during the initial open of a tty/pty pair in order to set up the
602 * line discplines and bind them to the tty.
603 */
604
605int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
606{
607 struct tty_ldisc *ld = &tty->ldisc;
608 int retval;
609
610 if (ld->ops->open) {
611 retval = (ld->ops->open)(tty);
612 if (retval)
613 return retval;
614 }
615 if (o_tty && o_tty->ldisc.ops->open) {
616 retval = (o_tty->ldisc.ops->open)(o_tty);
617 if (retval) {
618 if (ld->ops->close)
619 (ld->ops->close)(tty);
620 return retval;
621 }
622 tty_ldisc_enable(o_tty);
623 }
624 tty_ldisc_enable(tty);
625 return 0;
626}
627
628/**
629 * tty_ldisc_release - release line discipline
630 * @tty: tty being shut down
631 * @o_tty: pair tty for pty/tty pairs
632 *
633 * Called during the final close of a tty/pty pair in order to shut down the
634 * line discpline layer.
635 */
636
637void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
638{
639 unsigned long flags;
640 struct tty_ldisc ld;
641 /*
642 * Prevent flush_to_ldisc() from rescheduling the work for later. Then
643 * kill any delayed work. As this is the final close it does not
644 * race with the set_ldisc code path.
645 */
646 clear_bit(TTY_LDISC, &tty->flags);
647 cancel_delayed_work(&tty->buf.work);
648
649 /*
650 * Wait for ->hangup_work and ->buf.work handlers to terminate
651 */
652
653 flush_scheduled_work();
654
655 /*
656 * Wait for any short term users (we know they are just driver
657 * side waiters as the file is closing so user count on the file
658 * side is zero.
659 */
660 spin_lock_irqsave(&tty_ldisc_lock, flags);
661 while (tty->ldisc.refcount) {
662 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
663 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
664 spin_lock_irqsave(&tty_ldisc_lock, flags);
665 }
666 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
667 /*
668 * Shutdown the current line discipline, and reset it to N_TTY.
669 *
670 * FIXME: this MUST get fixed for the new reflocking
671 */
672 if (tty->ldisc.ops->close)
673 (tty->ldisc.ops->close)(tty);
674 tty_ldisc_put(tty->ldisc.ops);
675
676 /*
677 * Switch the line discipline back
678 */
679 WARN_ON(tty_ldisc_get(N_TTY, &ld));
680 tty_ldisc_assign(tty, &ld);
681 tty_set_termios_ldisc(tty, N_TTY);
682 if (o_tty) {
683 /* FIXME: could o_tty be in setldisc here ? */
684 clear_bit(TTY_LDISC, &o_tty->flags);
685 if (o_tty->ldisc.ops->close)
686 (o_tty->ldisc.ops->close)(o_tty);
687 tty_ldisc_put(o_tty->ldisc.ops);
688 WARN_ON(tty_ldisc_get(N_TTY, &ld));
689 tty_ldisc_assign(o_tty, &ld);
690 tty_set_termios_ldisc(o_tty, N_TTY);
691 }
692}
693
694/**
695 * tty_ldisc_init - ldisc setup for new tty
696 * @tty: tty being allocated
697 *
698 * Set up the line discipline objects for a newly allocated tty. Note that
699 * the tty structure is not completely set up when this call is made.
700 */
701
702void tty_ldisc_init(struct tty_struct *tty)
703{
704 struct tty_ldisc ld;
705 if (tty_ldisc_get(N_TTY, &ld) < 0)
706 panic("n_tty: init_tty");
707 tty_ldisc_assign(tty, &ld);
708}
709
710void tty_ldisc_begin(void)
711{
712 /* Setup the default TTY line discipline. */
713 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
714}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-28 20:36:38 -0500