tree e872c4fcbbf661cccd40d5c414801544c5ef8a5c
parent e95a9ec1bb66e07b138861c743192f06e7b3e4de
author Marc Zyngier <maz@misterjones.org> 1141038480 +0100
committer Linus Torvalds <torvalds@g5.osdl.org> 1141057084 -0800

[PATCH] Fix Specialix SX corruption

With the latest kernels, I experienced some strange corruption, some
'*****' being randomly inserted in the character flow, like this:

	ashes:~#
	ashes:~#
	a*******shes:~#
	ashes:~#
	ashes:~#

Further investigation shows that the problem was introduced during
Alan's "TTY layer buffering revamp" patch, the amount of data to be
copied being reduced after buffer allocation.  Moving the count fixup
around solves the problem.

Signed-off-by: Marc Zyngier <maz@misterjones.org>
Approved-by: Rogier Wolff <R.E.Wolff@BitWizard.nl>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
