AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-30 03:46:42 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

pty: Narrow the race on ldisc locking

Browse Source 
The pty code has always been buggy on its ldisc handling. The recent
changes made the window for the race much bigger. Pending fixing it
properly which is not at all trivial, at least make the race small again so
we don't disrupt other dev work.

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alan Cox 2009-06-16 17:01:13 +01:00 committed by Linus Torvalds
parent 5dca607bcf
commit 762faaed91
1 changed files with 39 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
drivers/char/pty.c
View File

@ -95,23 +95,34 @@ static void pty_unthrottle(struct tty_struct *tty)
* a count. * a count.
* *
* FIXME: Our pty_write method is called with our ldisc lock held but * FIXME: Our pty_write method is called with our ldisc lock held but
* not our partners. We can't just take the other one blindly without * not our partners. We can't just wait on the other one blindly without
* risking deadlocks. * risking deadlocks. At some point when everything has settled down we need
* to look into making pty_write at least able to sleep over an ldisc change.
*
* The return on no ldisc is a bit counter intuitive but the logic works
* like this. During an ldisc change the other end will flush its buffers. We
* thus return the full length which is identical to the case where we had
* proper locking and happened to queue the bytes just before the flush during
* the ldisc change.
*/ */
static int pty_write(struct tty_struct *tty, const unsigned char *buf, static int pty_write(struct tty_struct *tty, const unsigned char *buf,
int count) int count)
{ {
struct tty_struct *to = tty->link; struct tty_struct *to = tty->link;
int c; struct tty_ldisc *ld;
int c = count;
if (!to || tty->stopped) if (!to || tty->stopped)
return 0; return 0;
ld = tty_ldisc_ref(to);
c = to->receive_room; if (ld) {
if (c > count) c = to->receive_room;
c = count; if (c > count)
to->ldisc->ops->receive_buf(to, buf, NULL, c); c = count;
ld->ops->receive_buf(to, buf, NULL, c);
tty_ldisc_deref(ld);
}
return c; return c;
} }
@ -145,14 +156,23 @@ static int pty_write_room(struct tty_struct *tty)
static int pty_chars_in_buffer(struct tty_struct *tty) static int pty_chars_in_buffer(struct tty_struct *tty)
{ {
struct tty_struct *to = tty->link; struct tty_struct *to = tty->link;
int count; struct tty_ldisc *ld;
int count = 0;
/* We should get the line discipline lock for "tty->link" */ /* We should get the line discipline lock for "tty->link" */
if (!to || !to->ldisc->ops->chars_in_buffer) if (!to)
return 0;
/* We cannot take a sleeping reference here without deadlocking with
an ldisc change - but it doesn't really matter */
ld = tty_ldisc_ref(to);
if (ld == NULL)
return 0; return 0;
/* The ldisc must report 0 if no characters available to be read */ /* The ldisc must report 0 if no characters available to be read */
count = to->ldisc->ops->chars_in_buffer(to); if (ld->ops->chars_in_buffer)
count = ld->ops->chars_in_buffer(to);
tty_ldisc_deref(ld);
if (tty->driver->subtype == PTY_TYPE_SLAVE) if (tty->driver->subtype == PTY_TYPE_SLAVE)
return count; return count;
@ -182,12 +202,19 @@ static void pty_flush_buffer(struct tty_struct *tty)
{ {
struct tty_struct *to = tty->link; struct tty_struct *to = tty->link;
unsigned long flags; unsigned long flags;
struct tty_ldisc *ld;
if (!to) if (!to)
return; return;
ld = tty_ldisc_ref(to);
if (to->ldisc->ops->flush_buffer) /* The other end is changing discipline */
if (!ld)
return;
if (ld->ops->flush_buffer)
to->ldisc->ops->flush_buffer(to); to->ldisc->ops->flush_buffer(to);
tty_ldisc_deref(ld);
if (to->packet) { if (to->packet) {
spin_lock_irqsave(&tty->ctrl_lock, flags); spin_lock_irqsave(&tty->ctrl_lock, flags);