Skip to content

Commit

Permalink
speakup: Reference synth from tty and tty from synth
Browse files Browse the repository at this point in the history
We do not actually need speakup_tty and spk_ttyio_synth global
variables, the synth can store the pointer to the tty, and the tty
ldisc_data can store the pointer to the synth.

Along the way, we can clench the initialization of the synth and the
creation of the tty, so that tty is never NULL. Even if the device
disappears (e.g. USB unplug), the tty structure will still be there,
and we automatically stop speakup in the spk_ttyio_out error handler
but keep tty until the user cleans things up.

As a result, this simplifies locking a lot.

Signed-off-by: Samuel Thibault <[email protected]>
Link: https://lore.kernel.org/r/[email protected]
Signed-off-by: Greg Kroah-Hartman <[email protected]>
  • Loading branch information
sthibaul authored and gregkh committed Jan 27, 2021
1 parent 1941ab1 commit 4f2a81f
Show file tree
Hide file tree
Showing 2 changed files with 46 additions and 73 deletions.
117 changes: 44 additions & 73 deletions drivers/accessibility/speakup/spk_ttyio.c
Original file line number Diff line number Diff line change
Expand Up @@ -12,14 +12,15 @@ struct spk_ldisc_data {
char buf;
struct completion completion;
bool buf_free;
struct spk_synth *synth;
};

static struct spk_synth *spk_ttyio_synth;
static struct tty_struct *speakup_tty;
/* mutex to protect against speakup_tty disappearing from underneath us while
* we are using it. this can happen when the device physically unplugged,
* while in use. it also serialises access to speakup_tty.
/*
* This allows to catch within spk_ttyio_ldisc_open whether it is getting set
* on for a speakup-driven device.
*/
static struct tty_struct *speakup_tty;
/* This mutex serializes the use of such global speakup_tty variable */
static DEFINE_MUTEX(speakup_tty_mutex);

static int ser_to_dev(int ser, dev_t *dev_no)
Expand Down Expand Up @@ -67,22 +68,20 @@ static int spk_ttyio_ldisc_open(struct tty_struct *tty)

static void spk_ttyio_ldisc_close(struct tty_struct *tty)
{
mutex_lock(&speakup_tty_mutex);
kfree(speakup_tty->disc_data);
speakup_tty = NULL;
mutex_unlock(&speakup_tty_mutex);
kfree(tty->disc_data);
}

static int spk_ttyio_receive_buf2(struct tty_struct *tty,
const unsigned char *cp, char *fp, int count)
{
struct spk_ldisc_data *ldisc_data = tty->disc_data;
struct spk_synth *synth = ldisc_data->synth;

if (spk_ttyio_synth->read_buff_add) {
if (synth->read_buff_add) {
int i;

for (i = 0; i < count; i++)
spk_ttyio_synth->read_buff_add(cp[i]);
synth->read_buff_add(cp[i]);

return count;
}
Expand Down Expand Up @@ -187,13 +186,17 @@ static int spk_ttyio_initialise_ldisc(struct spk_synth *synth)
mutex_lock(&speakup_tty_mutex);
speakup_tty = tty;
ret = tty_set_ldisc(tty, N_SPEAKUP);
if (ret)
speakup_tty = NULL;
speakup_tty = NULL;
mutex_unlock(&speakup_tty_mutex);

if (!ret)
if (!ret) {
/* Success */
struct spk_ldisc_data *ldisc_data = tty->disc_data;

ldisc_data->synth = synth;
synth->dev = tty;
return 0;
}

pr_err("speakup: Failed to set N_SPEAKUP on tty\n");

Expand Down Expand Up @@ -221,11 +224,11 @@ void spk_ttyio_unregister_ldisc(void)

static int spk_ttyio_out(struct spk_synth *in_synth, const char ch)
{
mutex_lock(&speakup_tty_mutex);
if (in_synth->alive && speakup_tty && speakup_tty->ops->write) {
int ret = speakup_tty->ops->write(speakup_tty, &ch, 1);
struct tty_struct *tty = in_synth->dev;

if (in_synth->alive && tty->ops->write) {
int ret = tty->ops->write(tty, &ch, 1);

mutex_unlock(&speakup_tty_mutex);
if (ret == 0)
/* No room */
return 0;
Expand All @@ -243,7 +246,6 @@ static int spk_ttyio_out(struct spk_synth *in_synth, const char ch)
return 1;
}

mutex_unlock(&speakup_tty_mutex);
return 0;
}

Expand All @@ -264,47 +266,20 @@ static int spk_ttyio_out_unicode(struct spk_synth *in_synth, u16 ch)
return ret;
}

static int check_tty(struct tty_struct *tty)
{
if (!tty) {
pr_warn("%s: I/O error, deactivating speakup\n",
spk_ttyio_synth->long_name);
/* No synth any more, so nobody will restart TTYs, and we thus
* need to do it ourselves. Now that there is no synth we can
* let application flood anyway
*/
spk_ttyio_synth->alive = 0;
speakup_start_ttys();
return 1;
}

return 0;
}

static void spk_ttyio_send_xchar(struct spk_synth *in_synth, char ch)
{
mutex_lock(&speakup_tty_mutex);
if (check_tty(speakup_tty)) {
mutex_unlock(&speakup_tty_mutex);
return;
}
struct tty_struct *tty = in_synth->dev;

if (speakup_tty->ops->send_xchar)
speakup_tty->ops->send_xchar(speakup_tty, ch);
mutex_unlock(&speakup_tty_mutex);
if (tty->ops->send_xchar)
tty->ops->send_xchar(tty, ch);
}

static void spk_ttyio_tiocmset(struct spk_synth *in_synth, unsigned int set, unsigned int clear)
{
mutex_lock(&speakup_tty_mutex);
if (check_tty(speakup_tty)) {
mutex_unlock(&speakup_tty_mutex);
return;
}
struct tty_struct *tty = in_synth->dev;

if (speakup_tty->ops->tiocmset)
speakup_tty->ops->tiocmset(speakup_tty, set, clear);
mutex_unlock(&speakup_tty_mutex);
if (tty->ops->tiocmset)
tty->ops->tiocmset(tty, set, clear);
}

static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth)
Expand All @@ -314,7 +289,8 @@ static int spk_ttyio_wait_for_xmitr(struct spk_synth *in_synth)

static unsigned char ttyio_in(struct spk_synth *in_synth, int timeout)
{
struct spk_ldisc_data *ldisc_data = speakup_tty->disc_data;
struct tty_struct *tty = in_synth->dev;
struct spk_ldisc_data *ldisc_data = tty->disc_data;
char rv;

if (!timeout) {
Expand All @@ -334,7 +310,7 @@ static unsigned char ttyio_in(struct spk_synth *in_synth, int timeout)
mb();
ldisc_data->buf_free = true;
/* Let TTY push more characters */
tty_schedule_flip(speakup_tty->port);
tty_schedule_flip(tty->port);

return rv;
}
Expand All @@ -353,16 +329,10 @@ static unsigned char spk_ttyio_in_nowait(struct spk_synth *in_synth)

static void spk_ttyio_flush_buffer(struct spk_synth *in_synth)
{
mutex_lock(&speakup_tty_mutex);
if (check_tty(speakup_tty)) {
mutex_unlock(&speakup_tty_mutex);
return;
}

if (speakup_tty->ops->flush_buffer)
speakup_tty->ops->flush_buffer(speakup_tty);
struct tty_struct *tty = in_synth->dev;

mutex_unlock(&speakup_tty_mutex);
if (tty->ops->flush_buffer)
tty->ops->flush_buffer(tty);
}

int spk_ttyio_synth_probe(struct spk_synth *synth)
Expand All @@ -373,36 +343,37 @@ int spk_ttyio_synth_probe(struct spk_synth *synth)
return rv;

synth->alive = 1;
spk_ttyio_synth = synth;

return 0;
}
EXPORT_SYMBOL_GPL(spk_ttyio_synth_probe);

void spk_ttyio_release(struct spk_synth *in_synth)
{
if (!speakup_tty)
return;
struct tty_struct *tty = in_synth->dev;

tty_lock(speakup_tty);
tty_lock(tty);

if (speakup_tty->ops->close)
speakup_tty->ops->close(speakup_tty, NULL);
if (tty->ops->close)
tty->ops->close(tty, NULL);

tty_ldisc_flush(tty);
tty_unlock(tty);
tty_kclose(tty);

tty_ldisc_flush(speakup_tty);
tty_unlock(speakup_tty);
tty_kclose(speakup_tty);
in_synth->dev = NULL;
}
EXPORT_SYMBOL_GPL(spk_ttyio_release);

const char *spk_ttyio_synth_immediate(struct spk_synth *in_synth, const char *buff)
{
struct tty_struct *tty = in_synth->dev;
u_char ch;

while ((ch = *buff)) {
if (ch == '\n')
ch = in_synth->procspeech;
if (tty_write_room(speakup_tty) < 1 ||
if (tty_write_room(tty) < 1 ||
!in_synth->io_ops->synth_out(in_synth, ch))
return buff;
buff++;
Expand Down
2 changes: 2 additions & 0 deletions drivers/accessibility/speakup/spk_types.h
Original file line number Diff line number Diff line change
Expand Up @@ -200,6 +200,8 @@ struct spk_synth {
struct synth_indexing indexing;
int alive;
struct attribute_group attributes;

void *dev;
};

/*
Expand Down

0 comments on commit 4f2a81f

Please sign in to comment.