mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
d5a9597d69
Today, all possible serial lines (ssl*=) as well as all possible consoles (con*=) each share a single interrupt (with a fixed number) with others of the same type. Now, if you have two lines, say ssl0 and ssl1, and one of them is connected to an fd you cannot read (e.g. a file), but the other gets a read interrupt, then both of them get the interrupt since it's shared. Then, the read() call will return EOF, since it's a file being written and there's nothing to read (at least not at the current offset, at the end). Unfortunately, this is treated as a read error, and we close this line, losing all the possible output. It might be possible to work around this and make the IRQ sharing work, however, now that we have dynamically allocated IRQs that are easy to use, simply use that to achieve separating between the events; then there's no interrupt for that line and we never attempt the read in the first place, thus not closing the line. This manifested itself in the wifi hostap/hwsim tests where the parallel script communicates via one serial console and the kernel messages go to another (a file) and sending data on the communication console caused the kernel messages to stop flowing into the file. Reported-by: Jouni Malinen <j@w1.fi> Signed-off-by: Johannes Berg <johannes.berg@intel.com> Acked-By: anton ivanov <anton.ivanov@cambridgegreys.com> Signed-off-by: Richard Weinberger <richard@nod.at>
97 lines
3 KiB
C
97 lines
3 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
|
|
*/
|
|
|
|
#ifndef __LINE_H__
|
|
#define __LINE_H__
|
|
|
|
#include <linux/list.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/tty.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/mutex.h>
|
|
#include "chan_user.h"
|
|
#include "mconsole_kern.h"
|
|
|
|
/* There's only two modifiable fields in this - .mc.list and .driver */
|
|
struct line_driver {
|
|
const char *name;
|
|
const char *device_name;
|
|
const short major;
|
|
const short minor_start;
|
|
const short type;
|
|
const short subtype;
|
|
const char *read_irq_name;
|
|
const char *write_irq_name;
|
|
struct mc_device mc;
|
|
struct tty_driver *driver;
|
|
};
|
|
|
|
struct line {
|
|
struct tty_port port;
|
|
int valid;
|
|
|
|
int read_irq, write_irq;
|
|
|
|
char *init_str;
|
|
struct list_head chan_list;
|
|
struct chan *chan_in, *chan_out;
|
|
|
|
/*This lock is actually, mostly, local to*/
|
|
spinlock_t lock;
|
|
int throttled;
|
|
/* Yes, this is a real circular buffer.
|
|
* XXX: And this should become a struct kfifo!
|
|
*
|
|
* buffer points to a buffer allocated on demand, of length
|
|
* LINE_BUFSIZE, head to the start of the ring, tail to the end.*/
|
|
char *buffer;
|
|
char *head;
|
|
char *tail;
|
|
|
|
int sigio;
|
|
struct delayed_work task;
|
|
const struct line_driver *driver;
|
|
};
|
|
|
|
extern void line_close(struct tty_struct *tty, struct file * filp);
|
|
extern int line_open(struct tty_struct *tty, struct file *filp);
|
|
extern int line_install(struct tty_driver *driver, struct tty_struct *tty,
|
|
struct line *line);
|
|
extern void line_cleanup(struct tty_struct *tty);
|
|
extern void line_hangup(struct tty_struct *tty);
|
|
extern int line_setup(char **conf, unsigned nlines, char **def,
|
|
char *init, char *name);
|
|
extern int line_write(struct tty_struct *tty, const unsigned char *buf,
|
|
int len);
|
|
extern unsigned int line_chars_in_buffer(struct tty_struct *tty);
|
|
extern void line_flush_buffer(struct tty_struct *tty);
|
|
extern void line_flush_chars(struct tty_struct *tty);
|
|
extern unsigned int line_write_room(struct tty_struct *tty);
|
|
extern void line_throttle(struct tty_struct *tty);
|
|
extern void line_unthrottle(struct tty_struct *tty);
|
|
|
|
extern char *add_xterm_umid(char *base);
|
|
extern int line_setup_irq(int fd, int input, int output, struct line *line,
|
|
void *data);
|
|
extern void line_close_chan(struct line *line);
|
|
extern int register_lines(struct line_driver *line_driver,
|
|
const struct tty_operations *driver,
|
|
struct line *lines, int nlines);
|
|
extern int setup_one_line(struct line *lines, int n, char *init,
|
|
const struct chan_opts *opts, char **error_out);
|
|
extern void close_lines(struct line *lines, int nlines);
|
|
|
|
extern int line_config(struct line *lines, unsigned int sizeof_lines,
|
|
char *str, const struct chan_opts *opts,
|
|
char **error_out);
|
|
extern int line_id(char **str, int *start_out, int *end_out);
|
|
extern int line_remove(struct line *lines, unsigned int sizeof_lines, int n,
|
|
char **error_out);
|
|
extern int line_get_config(char *dev, struct line *lines,
|
|
unsigned int sizeof_lines, char *str,
|
|
int size, char **error_out);
|
|
|
|
#endif
|