Lines Matching refs:ldata
134 static inline size_t read_cnt(struct n_tty_data *ldata)
136 return ldata->read_head - ldata->read_tail;
139 static inline u8 read_buf(struct n_tty_data *ldata, size_t i)
141 return ldata->read_buf[MASK(i)];
144 static inline u8 *read_buf_addr(struct n_tty_data *ldata, size_t i)
146 return &ldata->read_buf[MASK(i)];
149 static inline u8 echo_buf(struct n_tty_data *ldata, size_t i)
152 return ldata->echo_buf[MASK(i)];
155 static inline u8 *echo_buf_addr(struct n_tty_data *ldata, size_t i)
157 return &ldata->echo_buf[MASK(i)];
170 struct n_tty_data *ldata = tty->disc_data;
172 void *from = read_buf_addr(ldata, tail);
180 from = ldata->read_buf;
201 struct n_tty_data *ldata = tty->disc_data;
204 if (unlikely(READ_ONCE(ldata->no_room))) {
205 WRITE_ONCE(ldata->no_room, 0);
221 const struct n_tty_data *ldata = tty->disc_data;
222 size_t head = ldata->icanon ? ldata->canon_head : ldata->commit_head;
224 return head - ldata->read_tail;
242 struct n_tty_data *ldata = tty->disc_data;
249 if (ldata->icanon && ldata->canon_head == ldata->read_tail)
255 if (N_TTY_BUF_SIZE - read_cnt(ldata) >= TTY_THRESHOLD_THROTTLE)
298 * @ldata: n_tty data
306 static inline void put_tty_queue(u8 c, struct n_tty_data *ldata)
308 *read_buf_addr(ldata, ldata->read_head) = c;
309 ldata->read_head++;
314 * @ldata: line disc data to reset
323 static void reset_buffer_flags(struct n_tty_data *ldata)
325 ldata->read_head = ldata->canon_head = ldata->read_tail = 0;
326 ldata->commit_head = 0;
327 ldata->line_start = 0;
329 ldata->erasing = 0;
330 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
331 ldata->push = 0;
333 ldata->lookahead_count = 0;
419 struct n_tty_data *ldata = tty->disc_data;
428 ldata->column = 0;
432 ldata->canon_column = ldata->column = 0;
436 ldata->canon_column = ldata->column;
439 if (O_ONOCR(tty) && ldata->column == 0)
444 ldata->canon_column = ldata->column = 0;
447 ldata->canon_column = ldata->column = 0;
450 spaces = 8 - (ldata->column & 7);
454 ldata->column += spaces;
458 ldata->column += spaces;
461 if (ldata->column > 0)
462 ldata->column--;
469 ldata->column++;
493 struct n_tty_data *ldata = tty->disc_data;
496 mutex_lock(&ldata->output_lock);
501 mutex_unlock(&ldata->output_lock);
529 struct n_tty_data *ldata = tty->disc_data;
534 mutex_lock(&ldata->output_lock);
538 mutex_unlock(&ldata->output_lock);
550 ldata->column = 0;
553 ldata->canon_column = ldata->column;
556 if (O_ONOCR(tty) && ldata->column == 0)
560 ldata->canon_column = ldata->column = 0;
565 if (ldata->column > 0)
566 ldata->column--;
573 ldata->column++;
581 mutex_unlock(&ldata->output_lock);
588 struct n_tty_data *ldata = tty->disc_data;
595 if (MASK(ldata->echo_commit) == MASK(*tail + 1))
602 op = echo_buf(ldata, *tail + 1);
608 if (MASK(ldata->echo_commit) == MASK(*tail + 2))
611 num_chars = echo_buf(ldata, *tail + 2);
621 num_chars += ldata->canon_column;
630 if (ldata->column > 0)
631 ldata->column--;
637 ldata->canon_column = ldata->column;
642 if (ldata->column > 0)
643 ldata->column--;
653 ldata->column++;
670 ldata->column += 2;
703 struct n_tty_data *ldata = tty->disc_data;
710 tail = ldata->echo_tail;
711 while (MASK(ldata->echo_commit) != MASK(tail)) {
712 c = echo_buf(ldata, tail);
739 while (ldata->echo_commit > tail &&
740 ldata->echo_commit - tail >= ECHO_DISCARD_WATERMARK) {
741 if (echo_buf(ldata, tail) == ECHO_OP_START) {
742 if (echo_buf(ldata, tail + 1) == ECHO_OP_ERASE_TAB)
751 ldata->echo_tail = tail;
757 struct n_tty_data *ldata = tty->disc_data;
761 mutex_lock(&ldata->output_lock);
762 head = ldata->echo_head;
763 ldata->echo_mark = head;
764 old = ldata->echo_commit - ldata->echo_tail;
769 nr = head - ldata->echo_tail;
772 mutex_unlock(&ldata->output_lock);
776 ldata->echo_commit = head;
778 mutex_unlock(&ldata->output_lock);
786 struct n_tty_data *ldata = tty->disc_data;
789 if (ldata->echo_mark == ldata->echo_tail)
792 mutex_lock(&ldata->output_lock);
793 ldata->echo_commit = ldata->echo_mark;
795 mutex_unlock(&ldata->output_lock);
804 struct n_tty_data *ldata = tty->disc_data;
807 ldata->echo_commit == ldata->echo_head)
810 mutex_lock(&ldata->output_lock);
811 ldata->echo_commit = ldata->echo_head;
813 mutex_unlock(&ldata->output_lock);
819 * @ldata: n_tty data
823 static inline void add_echo_byte(u8 c, struct n_tty_data *ldata)
825 *echo_buf_addr(ldata, ldata->echo_head) = c;
827 ldata->echo_head++;
832 * @ldata: n_tty data
836 static void echo_move_back_col(struct n_tty_data *ldata)
838 add_echo_byte(ECHO_OP_START, ldata);
839 add_echo_byte(ECHO_OP_MOVE_BACK_COL, ldata);
844 * @ldata: n_tty data
849 static void echo_set_canon_col(struct n_tty_data *ldata)
851 add_echo_byte(ECHO_OP_START, ldata);
852 add_echo_byte(ECHO_OP_SET_CANON_COL, ldata);
859 * @ldata: n_tty data
869 struct n_tty_data *ldata)
871 add_echo_byte(ECHO_OP_START, ldata);
872 add_echo_byte(ECHO_OP_ERASE_TAB, ldata);
881 add_echo_byte(num_chars, ldata);
887 * @ldata: line disc data
894 static void echo_char_raw(u8 c, struct n_tty_data *ldata)
897 add_echo_byte(ECHO_OP_START, ldata);
898 add_echo_byte(ECHO_OP_START, ldata);
900 add_echo_byte(c, ldata);
917 struct n_tty_data *ldata = tty->disc_data;
920 add_echo_byte(ECHO_OP_START, ldata);
921 add_echo_byte(ECHO_OP_START, ldata);
924 add_echo_byte(ECHO_OP_START, ldata);
925 add_echo_byte(c, ldata);
931 * @ldata: n_tty data
933 static inline void finish_erasing(struct n_tty_data *ldata)
935 if (ldata->erasing) {
936 echo_char_raw('/', ldata);
937 ldata->erasing = 0;
955 struct n_tty_data *ldata = tty->disc_data;
961 if (ldata->read_head == ldata->canon_head) {
971 ldata->read_head = ldata->canon_head;
975 ldata->read_head = ldata->canon_head;
976 finish_erasing(ldata);
980 echo_char_raw('\n', ldata);
987 while (MASK(ldata->read_head) != MASK(ldata->canon_head)) {
988 head = ldata->read_head;
993 c = read_buf(ldata, head);
995 MASK(head) != MASK(ldata->canon_head));
1008 cnt = ldata->read_head - head;
1009 ldata->read_head = head;
1012 if (!ldata->erasing) {
1013 echo_char_raw('\\', ldata);
1014 ldata->erasing = 1;
1020 echo_char_raw(read_buf(ldata, head), ldata);
1021 echo_move_back_col(ldata);
1028 size_t tail = ldata->read_head;
1037 while (MASK(tail) != MASK(ldata->canon_head)) {
1039 c = read_buf(ldata, tail);
1050 echo_erase_tab(num_chars, after_tab, ldata);
1053 echo_char_raw('\b', ldata);
1054 echo_char_raw(' ', ldata);
1055 echo_char_raw('\b', ldata);
1058 echo_char_raw('\b', ldata);
1059 echo_char_raw(' ', ldata);
1060 echo_char_raw('\b', ldata);
1067 if (ldata->read_head == ldata->canon_head && L_ECHO(tty))
1068 finish_erasing(ldata);
1097 struct n_tty_data *ldata = tty->disc_data;
1110 mutex_lock(&ldata->output_lock);
1111 ldata->echo_head = ldata->echo_tail = 0;
1112 ldata->echo_mark = ldata->echo_commit = 0;
1113 mutex_unlock(&ldata->output_lock);
1144 struct n_tty_data *ldata = tty->disc_data;
1153 put_tty_queue('\377', ldata);
1154 put_tty_queue('\0', ldata);
1156 put_tty_queue('\0', ldata);
1171 struct n_tty_data *ldata = tty->disc_data;
1173 ldata->num_overrun++;
1174 if (time_is_before_jiffies(ldata->overrun_time + HZ)) {
1175 tty_warn(tty, "%u input overrun(s)\n", ldata->num_overrun);
1176 ldata->overrun_time = jiffies;
1177 ldata->num_overrun = 0;
1195 struct n_tty_data *ldata = tty->disc_data;
1201 put_tty_queue('\377', ldata);
1202 put_tty_queue('\0', ldata);
1203 put_tty_queue(c, ldata);
1205 put_tty_queue('\0', ldata);
1207 put_tty_queue(c, ldata);
1265 struct n_tty_data *ldata = tty->disc_data;
1267 set_bit(MASK(ldata->read_head), ldata->read_flags);
1268 put_tty_queue(c, ldata);
1269 smp_store_release(&ldata->canon_head, ldata->read_head);
1276 struct n_tty_data *ldata = tty->disc_data;
1287 ldata->lnext = 1;
1289 finish_erasing(ldata);
1291 echo_char_raw('^', ldata);
1292 echo_char_raw('\b', ldata);
1301 size_t tail = ldata->canon_head;
1303 finish_erasing(ldata);
1305 echo_char_raw('\n', ldata);
1306 while (MASK(tail) != MASK(ldata->read_head)) {
1307 echo_char(read_buf(ldata, tail), tty);
1317 echo_char_raw('\n', ldata);
1339 if (ldata->canon_head == ldata->read_head)
1340 echo_set_canon_col(ldata);
1349 put_tty_queue(c, ldata);
1362 struct n_tty_data *ldata = tty->disc_data;
1393 if (ldata->icanon && n_tty_receive_char_canon(tty, c))
1397 finish_erasing(ldata);
1399 echo_char_raw('\n', ldata);
1402 if (ldata->canon_head == ldata->read_head)
1403 echo_set_canon_col(ldata);
1411 put_tty_queue(c, ldata);
1413 put_tty_queue(c, ldata);
1430 struct n_tty_data *ldata = tty->disc_data;
1437 finish_erasing(ldata);
1439 if (ldata->canon_head == ldata->read_head)
1440 echo_set_canon_col(ldata);
1446 put_tty_queue(c, ldata);
1447 put_tty_queue(c, ldata);
1492 struct n_tty_data *ldata = tty->disc_data;
1494 ldata->lnext = 0;
1509 struct n_tty_data *ldata = tty->disc_data;
1512 ldata->lookahead_count += count;
1530 struct n_tty_data *ldata = tty->disc_data;
1534 size_t head = MASK(ldata->read_head);
1537 memcpy(read_buf_addr(ldata, head), cp, n);
1539 ldata->read_head += n;
1549 struct n_tty_data *ldata = tty->disc_data;
1556 put_tty_queue(*cp++, ldata);
1580 struct n_tty_data *ldata = tty->disc_data;
1589 if (ldata->lnext) {
1604 put_tty_queue(c, ldata);
1608 if (test_bit(c, ldata->char_map))
1618 struct n_tty_data *ldata = tty->disc_data;
1620 size_t la_count = min(ldata->lookahead_count, count);
1622 if (ldata->real_raw)
1624 else if (ldata->raw || (L_EXTPROC(tty) && !preops))
1642 ldata->lookahead_count -= la_count;
1644 if (ldata->icanon && !L_EXTPROC(tty))
1648 smp_store_release(&ldata->commit_head, ldata->read_head);
1650 if (read_cnt(ldata)) {
1693 struct n_tty_data *ldata = tty->disc_data;
1713 size_t tail = smp_load_acquire(&ldata->read_tail);
1715 room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
1720 overflow = ldata->icanon && ldata->canon_head == tail;
1722 ldata->read_head--;
1724 WRITE_ONCE(ldata->no_room, flow && !room);
1755 if (unlikely(ldata->no_room)) {
1759 * before ldata->no_room is set.
1797 struct n_tty_data *ldata = tty->disc_data;
1800 bitmap_zero(ldata->read_flags, N_TTY_BUF_SIZE);
1801 ldata->line_start = ldata->read_tail;
1802 if (!L_ICANON(tty) || !read_cnt(ldata)) {
1803 ldata->canon_head = ldata->read_tail;
1804 ldata->push = 0;
1806 set_bit(MASK(ldata->read_head - 1), ldata->read_flags);
1807 ldata->canon_head = ldata->read_head;
1808 ldata->push = 1;
1810 ldata->commit_head = ldata->read_head;
1811 ldata->erasing = 0;
1812 ldata->lnext = 0;
1815 ldata->icanon = (L_ICANON(tty) != 0);
1821 bitmap_zero(ldata->char_map, 256);
1824 set_bit('\r', ldata->char_map);
1826 set_bit('\n', ldata->char_map);
1829 set_bit(ERASE_CHAR(tty), ldata->char_map);
1830 set_bit(KILL_CHAR(tty), ldata->char_map);
1831 set_bit(EOF_CHAR(tty), ldata->char_map);
1832 set_bit('\n', ldata->char_map);
1833 set_bit(EOL_CHAR(tty), ldata->char_map);
1835 set_bit(WERASE_CHAR(tty), ldata->char_map);
1836 set_bit(LNEXT_CHAR(tty), ldata->char_map);
1837 set_bit(EOL2_CHAR(tty), ldata->char_map);
1840 ldata->char_map);
1844 set_bit(START_CHAR(tty), ldata->char_map);
1845 set_bit(STOP_CHAR(tty), ldata->char_map);
1848 set_bit(INTR_CHAR(tty), ldata->char_map);
1849 set_bit(QUIT_CHAR(tty), ldata->char_map);
1850 set_bit(SUSP_CHAR(tty), ldata->char_map);
1852 clear_bit(__DISABLED_CHAR, ldata->char_map);
1853 ldata->raw = 0;
1854 ldata->real_raw = 0;
1856 ldata->raw = 1;
1860 ldata->real_raw = 1;
1862 ldata->real_raw = 0;
1888 struct n_tty_data *ldata = tty->disc_data;
1894 vfree(ldata);
1909 struct n_tty_data *ldata;
1912 ldata = vzalloc(sizeof(*ldata));
1913 if (!ldata)
1916 ldata->overrun_time = jiffies;
1917 mutex_init(&ldata->atomic_read_lock);
1918 mutex_init(&ldata->output_lock);
1920 tty->disc_data = ldata;
1931 const struct n_tty_data *ldata = tty->disc_data;
1934 if (ldata->icanon && !L_EXTPROC(tty))
1935 return ldata->canon_head != ldata->read_tail;
1937 return ldata->commit_head - ldata->read_tail >= amt;
1953 * * called under the @ldata->atomic_read_lock sem
1962 struct n_tty_data *ldata = tty->disc_data;
1965 size_t head = smp_load_acquire(&ldata->commit_head);
1966 size_t tail = MASK(ldata->read_tail);
1968 n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail);
1971 u8 *from = read_buf_addr(ldata, tail);
1976 smp_store_release(&ldata->read_tail, ldata->read_tail + n);
1978 if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
1979 (head == ldata->read_tail))
1985 return head != ldata->read_tail;
2015 struct n_tty_data *ldata = tty->disc_data;
2025 canon_head = smp_load_acquire(&ldata->canon_head);
2026 n = min(*nr, canon_head - ldata->read_tail);
2028 tail = MASK(ldata->read_tail);
2034 eol = find_next_bit(ldata->read_flags, size, tail);
2038 eol = find_first_bit(ldata->read_flags, more);
2048 if (!found || read_buf(ldata, eol) != __DISABLED_CHAR)
2059 clear_bit(eol, ldata->read_flags);
2060 smp_store_release(&ldata->read_tail, ldata->read_tail + c);
2063 if (!ldata->push)
2064 ldata->line_start = ldata->read_tail;
2066 ldata->push = 0;
2072 return ldata->read_tail != canon_head;
2080 static void canon_skip_eof(struct n_tty_data *ldata)
2084 canon_head = smp_load_acquire(&ldata->canon_head);
2085 tail = ldata->read_tail;
2093 if (!test_bit(tail, ldata->read_flags))
2095 if (read_buf(ldata, tail) != __DISABLED_CHAR)
2099 clear_bit(tail, ldata->read_flags);
2100 smp_store_release(&ldata->read_tail, ldata->read_tail + 1);
2154 struct n_tty_data *ldata = tty->disc_data;
2171 if (ldata->icanon && !L_EXTPROC(tty)) {
2178 canon_skip_eof(ldata);
2190 mutex_unlock(&ldata->atomic_read_lock);
2203 if (!mutex_trylock(&ldata->atomic_read_lock))
2206 if (mutex_lock_interruptible(&ldata->atomic_read_lock))
2214 if (!ldata->icanon) {
2225 old_tail = ldata->read_tail;
2280 if (ldata->icanon && !L_EXTPROC(tty)) {
2314 if (old_tail != ldata->read_tail) {
2317 * before setting ldata->read_tail in copy_from_read_buf().
2325 mutex_unlock(&ldata->atomic_read_lock);
2402 struct n_tty_data *ldata = tty->disc_data;
2405 mutex_lock(&ldata->output_lock);
2407 mutex_unlock(&ldata->output_lock);
2479 static unsigned long inq_canon(struct n_tty_data *ldata)
2483 if (ldata->canon_head == ldata->read_tail)
2485 head = ldata->canon_head;
2486 tail = ldata->read_tail;
2490 if (test_bit(MASK(tail), ldata->read_flags) &&
2491 read_buf(ldata, tail) == __DISABLED_CHAR)
2501 struct n_tty_data *ldata = tty->disc_data;
2510 retval = inq_canon(ldata);
2512 retval = read_cnt(ldata);