Skip to contentSkip to conversation

new tty buffering locking fix

PATCH Olaf Hering 3 participants 10 messages Feb 7, 2006 – Feb 8, 2006 1 message not in the archive

Subsystems (2)
lore
Share & tools
lore
#1 lore raw
In reply to a message not in the archive
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

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
#2 lore raw
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 *h
 				tty_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 *h
 			tty_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 *h
 
 	spin_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 */
#3 lore raw
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
#4 lore raw
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
#5 lore raw
In reply to Olaf Hering

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_s
 	   remove 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;
 
#6 lore raw
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 ?

#7 lore raw
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

#8 lore raw
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

#9 lore raw
In reply to Alan Cox

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_s
 			if (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 *private
 	unsigned 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)
#10 lore raw
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