new tty buffering locking fix
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 19 lines · Linux Kernel Mailing List
[PATCH] new tty buffering locking fix
Change locking in the new tty buffering facility from using
tty->read_lock, which is currently ignored by drivers and thus ineffective. New locking uses a new tty buffering specific lock enforced centrally in the tty buffering code.Two drivers (esp and cyclades) are updated to use the tty buffering functions instead of accessing tty buffering internals directly. This is required for the new locking to work.
Minor checks for NULL buffers added to tty_prepare_flip_string/tty_prepare_flip_string_flags
Signed-off-by Paul Fulghum <[email protected]>Cc Alan Cox <[email protected]>Signed-off-by Andrew Morton <[email protected]>Signed-off-by Linus Torvalds <[email protected]>
Quoted 7 lines
drivers/char/cyclades.c | 6 +-- drivers/char/esp.c | 4 +- drivers/char/tty_io.c | 77 ++++++++++++++++++++++++++++++----------------- include/linux/kbd_kern.h | 5 +++ include/linux/tty.h | 2 + include/linux/tty_flip.h | 7 +++- 6 files changed, 68 insertions(+), 33 deletions(-)
This patch breaks the hvc console, no input is accepted, even with init=/bin/sash? Any idea what this driver needs to do now? I wonder if it worked ok on -mm.
Signature · 2 lines
short story of a lazy sysadmin: alias appserv=wotan
Quoted 5 lines · Olaf Hering
Quoted 1 line
[PATCH] new tty buffering locking fix
This patch breaks the hvc console, no input is accepted, even with init=/bin/sash? Any idea what this driver needs to do now? I wonder if it worked ok on -mm.
I think this is happening:
1. hvc calls tty_buffer_request_room, claiming a
tty buffer for use by the driver
2. hvc adds data to the tty buffer
3. hvc calls tty_schedule_flip or tty_flip_buffer_push, which releases the buffer for processing
4. *before* the buffer can be processed, hvc again calls tty_buffer_request_room, reclaiming the same buffer which still has free room
5. hvc does not have more data to input, so it does not call tty_schedule_flip or tty_flip_buffer_push
Now the tty buffer contains some data but can't be processed because it is still marked as in use by the driver.
Try the below patches (for testing only, I'm not suggesting these as a final fix yet) and let me know if it fixes it.
Thanks,
Paul
drivers/char/hvc_console.c +2 -2
@@ -613,6 +613,7 @@ static int hvc_poll(struct hvc_struct *htty_hangup (tty);spin_lock_irqsave (&hp->lock, flags); } +tty_schedule_flip (tty);break ; }for (i =0 ; i < n; ++i) {
@@ -633,8 +634,7 @@ static int hvc_poll(struct hvc_struct *htty_insert_flip_char (tty, buf[i],0 ); } -if (count) -tty_schedule_flip (tty); +tty_schedule_flip (tty);/* * Account for the total amount read in one loop, and if above
drivers/char/hvcs.c +1 -2
@@ -469,8 +469,7 @@ static int hvcs_io(struct hvcs_struct *hspin_unlock_irqrestore (&hvcsd->lock, flags);/* This is synch because tty->low_latency == 1 */ -if (got) -tty_flip_buffer_push (tty); +tty_flip_buffer_push (tty);if (!got) {/* Do this _after_ the flip_buffer_push */
Quoted 2 lines · Paul Fulghum
Try the below patches (for testing only, I'm not suggesting these as a final fix yet) and let me know if it fixes it.
Yes, this works for me.
Signature · 2 lines
short story of a lazy sysadmin: alias appserv=wotan
Quoted 6 lines · Olaf Hering
Quoted 2 lines · Paul Fulghum
Try the below patches (for testing only, I'm not suggesting these as a final fix yet) and let me know if it fixes it.
Yes, this works for me.
OK, good.
I'm working on a change to the locking patch that fixes this without modifying individual drivers such as hvc_console. I'll post something later today.
Signature · 2 lines
Paul Fulghum Microgate Systems, Ltd
Olaf:
Try this patch and let me know how it works. (it is against 2.6.16-rc2-git1)
This change prevents claiming a partially filled buffer if it has already been committed by the driver calling a tty scheduling function, but not yet processed by the tty layer.
Individual drivers can no longer stall committed data by calling any of the tty buffering functions. (example: calling tty_buffer_request_room and not immediately adding receive data with an associated tty scheduling call)
This remains relatively efficient.
1. partially filled active buffer can be reused
2. already allocated empty buffer can be reused
Thanks,
Paul
drivers/char/tty_io.c +8 -2
@@ -324,8 +324,14 @@ int tty_buffer_request_room(struct tty_sremove this conditional if its worth it. This would be invisible to the callers */ if ((b = tty->buf.tail) !=NULL ) { - left = b->size - b->used; - b->active =1 ; +if (!b->active) { +if (!b->used) { + left = b->size; + b->active =1 ; + }else + left =0 ; + }else + left = b->size - b->used; }else left =0 ;
Quoted 9 lines · Paul Fulghum
Olaf:
Try this patch and let me know how it works. (it is against 2.6.16-rc2-git1)
This change prevents claiming a partially filled buffer if it has already been committed by the driver calling a tty scheduling function, but not yet processed by the tty layer.
Thats going to hurt memory consumption in the worst cases. Might be better to document the sane behaviour and enforce it ?
Quoted 1 line · Alan Cox
Thats going to hurt memory consumption in the worst cases.
I'll gather some accounting info tomorrow,
and consider the more pathological cases.
Quoted 1 line
Might be better to document the sane behaviour and enforce it ?
That was my first thought, which prompted my
initial patch of the hvc drivers.
Requiring a call to schedule processing of tty data after preallocating buffer space is not obvious, and could result in scheduling work when there is no data to process.
This semantic twist introduced by my first locking patch is a hazard for driver writers, and would require an audit of existing drivers (as demonstrated by Olaf's report).
--
Paul Fulghum
Microgate Systems, Ltd
Quoted 6 lines · Paul Fulghum
Quoted 1 line · Alan Cox
Thats going to hurt memory consumption in the worst cases.
I'll gather some accounting info tomorrow,
and consider the more pathological cases.
Now that I think about it (ow!), there is a simple way to cap the memory penalty to a single extra buffer allocation and still maintain the existing interface behavior.
I'll post a new patch tomorrow.
Thanks,
Paul
--
Paul Fulghum
Microgate Systems, Ltd
Here is a different approach to prevent a driver from stalling pending receive data in the flip buffers by calling a tty buffer allocation function without a trailing call to a tty schedule function. This patch does not have the memory penalty of my previous patch for the worst case usage patterns.
Alan: let me know what you think.
Olaf: can you please test this with the hvc?
I am going to continue testing tomorrow,
but would like some early feedback.
Thanks,
Paul
include/linux/kbd_kern.h +3 -1
@@ -153,8 +153,10 @@ static inline void con_schedule_flip(str {unsigned long flags;spin_lock_irqsave (&t->buf.lock, flags); -if (t->buf.tail !=NULL ) +if (t->buf.tail !=NULL ) { t->buf.tail->active =0 ; + t->buf.tail->commit = t->buf.tail->used; + }spin_unlock_irqrestore (&t->buf.lock, flags);schedule_work (&t->buf.work); }
include/linux/tty_flip.h +3 -1
@@ -29,8 +29,10 @@ _INLINE_ void tty_schedule_flip(struct t {unsigned long flags;spin_lock_irqsave (&tty->buf.lock, flags); -if (tty->buf.tail !=NULL ) +if (tty->buf.tail !=NULL ) { tty->buf.tail->active =0 ; + tty->buf.tail->commit = tty->buf.tail->used; + }spin_unlock_irqrestore (&tty->buf.lock, flags);schedule_delayed_work (&tty->buf.work,1 ); }
include/linux/tty.h +2 -0
@@ -58,6 +58,8 @@ struct tty_buffer {int used;int size;int active; +int commit; +int read;/* Data points here */ unsigned long data[0 ]; };
drivers/char/tty_io.c +22 -8
@@ -268,6 +268,8 @@ static struct tty_buffer *tty_buffer_all p->size = size; p->next =NULL ; p->active =0 ; + p->commit =0 ; + p->read =0 ; p->char_buf_ptr = (char *)(p->data); p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;/* printk("Flip create %p\n", p); */
@@ -298,6 +300,8 @@ static struct tty_buffer *tty_buffer_fin *tbh = t->next; t->next =NULL ; t->used =0 ; + t->commit =0 ; + t->read =0 ;/* DEBUG ONLY */ memset (t->data,'*' , size);/* printk("Flip recycle %p\n", t); */
@@ -335,6 +339,7 @@ int tty_buffer_request_room(struct tty_sif (b !=NULL ) { b->next = n; b->active =0 ; + b->commit = b->used; }else tty->buf.head = n; tty->buf.tail = n;
@@ -2752,6 +2757,9 @@ static void flush_to_ldisc(void *privateunsigned long flags;struct tty_ldisc *disc;struct tty_buffer *tbuf; +int count; +char *char_buf; +unsigned char *flag_buf; disc =tty_ldisc_ref (tty);if (disc ==NULL )/* !TTY_LDISC */
@@ -2765,16 +2773,20 @@ static void flush_to_ldisc(void *private goto out; }spin_lock_irqsave (&tty->buf.lock, flags); -while ((tbuf = tty->buf.head) !=NULL && !tbuf->active) { +while ((tbuf = tty->buf.head) !=NULL ) { +while ((count = tbuf->commit - tbuf->read) !=0 ) { + char_buf = tbuf->char_buf_ptr + tbuf->read; + flag_buf = tbuf->flag_buf_ptr + tbuf->read; + tbuf->read += count; +spin_unlock_irqrestore (&tty->buf.lock, flags); + disc->receive_buf (tty, char_buf, flag_buf, count); +spin_lock_irqsave (&tty->buf.lock, flags); + } +if (tbuf->active) +break ; tty->buf.head = tbuf->next;if (tty->buf.head ==NULL ) tty->buf.tail =NULL ; -spin_unlock_irqrestore (&tty->buf.lock, flags); -/* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */ - disc->receive_buf (tty, tbuf->char_buf_ptr, - tbuf->flag_buf_ptr, - tbuf->used); -spin_lock_irqsave (&tty->buf.lock, flags);tty_buffer_free (tty, tbuf); }spin_unlock_irqrestore (&tty->buf.lock, flags);
@@ -2871,8 +2883,10 @@ void tty_flip_buffer_push(struct tty_str {unsigned long flags;spin_lock_irqsave (&tty->buf.lock, flags); -if (tty->buf.tail !=NULL ) +if (tty->buf.tail !=NULL ) { tty->buf.tail->active =0 ; + tty->buf.tail->commit = tty->buf.tail->used; + }spin_unlock_irqrestore (&tty->buf.lock, flags);if (tty->low_latency)
Quoted 1 line · Paul Fulghum
Olaf: can you please test this with the hvc?
Yes, works for me, tested with -git6
Signature · 2 lines
short story of a lazy sysadmin: alias appserv=wotan