lkml.org 
[lkml]   [2016]   [Jan]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v2 12/19] tty: Prepare for destroying line discipline on hangup
    Date
    tty file_operations (read/write/ioctl) wait for the ldisc reference
    indefinitely (until ldisc lifetime events, such as hangup or TIOCSETD,
    finish). Since hangup now destroys the ldisc and does not instance
    another copy, file_operations must now be prepared to receive a NULL
    ldisc reference from tty_ldisc_ref_wait():

    CPU 0 CPU 1
    ----- -----
    (*f_op->read)() => tty_read()
    __tty_hangup()
    ...
    f_op = &hung_up_tty_fops;
    ...
    tty_ldisc_hangup()
    tty_ldisc_lock()
    tty_ldisc_kill()
    tty->ldisc = NULL
    tty_ldisc_unlock()
    ld = tty_ldisc_ref_wait()
    /* ld == NULL */

    Instead, the action taken now is to return the same value as if the
    tty had been hungup a moment earlier:

    CPU 0 CPU 1
    ----- -----
    __tty_hangup()
    ...
    f_op = &hung_up_tty_fops;
    (*f_op->read)() => hung_up_tty_read()
    return 0;
    ...
    tty_ldisc_hangup()
    tty_ldisc_lock()
    tty_ldisc_kill()
    tty->ldisc = NULL
    tty_ldisc_unlock()

    Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
    ---
    drivers/tty/tty_io.c | 14 ++++++++++++++
    drivers/tty/tty_ldisc.c | 4 ++--
    drivers/tty/vt/selection.c | 2 ++
    3 files changed, 18 insertions(+), 2 deletions(-)

    diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
    index 0871d1e..89822c4 100644
    --- a/drivers/tty/tty_io.c
    +++ b/drivers/tty/tty_io.c
    @@ -1069,6 +1069,8 @@ static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
    /* We want to wait for the line discipline to sort out in this
    situation */
    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return hung_up_tty_read(file, buf, count, ppos);
    if (ld->ops->read)
    i = ld->ops->read(tty, file, buf, count);
    else
    @@ -1243,6 +1245,8 @@ static ssize_t tty_write(struct file *file, const char __user *buf,
    if (tty->ops->write_room == NULL)
    tty_err(tty, "missing write_room method\n");
    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return hung_up_tty_write(file, buf, count, ppos);
    if (!ld->ops->write)
    ret = -EIO;
    else
    @@ -2185,6 +2189,8 @@ static unsigned int tty_poll(struct file *filp, poll_table *wait)
    return 0;

    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return hung_up_tty_poll(filp, wait);
    if (ld->ops->poll)
    ret = ld->ops->poll(tty, filp, wait);
    tty_ldisc_deref(ld);
    @@ -2274,6 +2280,8 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
    return -EFAULT;
    tty_audit_tiocsti(tty, ch);
    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return -EIO;
    ld->ops->receive_buf(tty, &ch, &mbz, 1);
    tty_ldisc_deref(ld);
    return 0;
    @@ -2666,6 +2674,8 @@ static int tiocgetd(struct tty_struct *tty, int __user *p)
    int ret;

    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return -EIO;
    ret = put_user(ld->ops->num, p);
    tty_ldisc_deref(ld);
    return ret;
    @@ -2963,6 +2973,8 @@ long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    return retval;
    }
    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return hung_up_tty_ioctl(file, cmd, arg);
    retval = -EINVAL;
    if (ld->ops->ioctl) {
    retval = ld->ops->ioctl(tty, file, cmd, arg);
    @@ -2991,6 +3003,8 @@ static long tty_compat_ioctl(struct file *file, unsigned int cmd,
    }

    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return hung_up_tty_compat_ioctl(file, cmd, arg);
    if (ld->ops->compat_ioctl)
    retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
    else
    diff --git a/drivers/tty/tty_ldisc.c b/drivers/tty/tty_ldisc.c
    index 8582aeb..1c9ce25 100644
    --- a/drivers/tty/tty_ldisc.c
    +++ b/drivers/tty/tty_ldisc.c
    @@ -262,8 +262,8 @@ const struct file_operations tty_ldiscs_proc_fops = {
    * against a discipline change, such as an existing ldisc reference
    * (which we check for)
    *
    - * Note: only callable from a file_operations routine (which
    - * guarantees tty->ldisc != NULL when the lock is acquired).
    + * Note: a file_operations routine (read/poll/write) should use this
    + * function to wait for any ldisc lifetime events to finish.
    */

    struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
    diff --git a/drivers/tty/vt/selection.c b/drivers/tty/vt/selection.c
    index 381a2b1..4dd9dd2 100644
    --- a/drivers/tty/vt/selection.c
    +++ b/drivers/tty/vt/selection.c
    @@ -347,6 +347,8 @@ int paste_selection(struct tty_struct *tty)
    console_unlock();

    ld = tty_ldisc_ref_wait(tty);
    + if (!ld)
    + return -EIO; /* ldisc was hung up */
    tty_buffer_lock_exclusive(&vc->port);

    add_wait_queue(&vc->paste_wait, &wait);
    --
    2.7.0
    \
     
     \ /
      Last update: 2016-01-10 06:21    [W:6.289 / U:0.028 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site