* [PATCH v6 0/1] serial/8250: Use fifo in 8250 console driver
@ 2022-04-01 19:46 Wander Lairson Costa
2022-04-01 19:46 ` [PATCH v6] " Wander Lairson Costa
0 siblings, 1 reply; 5+ messages in thread
From: Wander Lairson Costa @ 2022-04-01 19:46 UTC (permalink / raw)
To: Greg Kroah-Hartman, Jiri Slaby, Johan Hovold, Maciej W. Rozycki,
Andy Shevchenko, Uwe Kleine-König, Wander Lairson Costa,
Lukas Wunner, Pali Rohár, open list:SERIAL DRIVERS,
open list
Cc: ilpo.jarvinen, rostedt, senozhatsky, andre.goddard,
sudipm.mukherjee, andy.shevchenko, David.Laight, jonathanh, phil
This is v6 of the serial fifo patch. In relation to the previous
reverted patch, I describe the main changes in the "What changed from
v3" section.
What changed from v5
--------------------
* Fixed a typo in patch patch "port-state" becomes "port->state".
What changed from v4
--------------------
* It squashes all the patches in a single patch
* It adds `port-state &&` check in the `use_fifo` condition as a
* preventive measure.
What changed from v3
--------------------
* Reads the FCR value from the port struct. The earlier patch
erroneously read the value from the controller, but FCR is a write-only
register. Thanks to Jiri Slaby for point this out.
* Use tx_loadsz as the transmitter fifo size. We previously used the
port->fifosize field, which caused data loss in some controllers. Thanks
Jon Hunter for the bug report.
* Exclude the BCM283x from fifo write. This is based on Phil Elwell's
original patch [1].
* Check if the port is initialized before write through fifo.
The serial driver set the value of uart_8250_port.fcr in the function
serial8250_config_port, but only writes the value to the controller
register later in the initalization code. That opens a small window in
which is not safe to use the fifo for console write. Unfortunately, I
lost track of who originally reported the issue. If s/he is reading
this, please speak up so I can give you the due credit.
[1] https://lore.kernel.org/all/20220126141124.4086065-1-phil@raspberrypi.com/
Wander Lairson Costa (1):
serial/8250: Use fifo in 8250 console driver
drivers/tty/serial/8250/8250_port.c | 68 ++++++++++++++++++++++++++---
1 file changed, 62 insertions(+), 6 deletions(-)
--
2.35.1
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v6] serial/8250: Use fifo in 8250 console driver
2022-04-01 19:46 [PATCH v6 0/1] serial/8250: Use fifo in 8250 console driver Wander Lairson Costa
@ 2022-04-01 19:46 ` Wander Lairson Costa
2022-04-04 9:32 ` Andy Shevchenko
0 siblings, 1 reply; 5+ messages in thread
From: Wander Lairson Costa @ 2022-04-01 19:46 UTC (permalink / raw)
To: Greg Kroah-Hartman, Jiri Slaby, Johan Hovold, Maciej W. Rozycki,
Andy Shevchenko, Lukas Wunner, Wander Lairson Costa,
Pali Rohár, open list:SERIAL DRIVERS, open list
Cc: ilpo.jarvinen, rostedt, senozhatsky, andre.goddard,
sudipm.mukherjee, andy.shevchenko, David.Laight, jonathanh, phil
Note: I am using a small test app + driver located at [0] for the
problem description. serco is a driver whose write function dispatches
to the serial controller. sertest is a user-mode app that writes n bytes
to the serial console using the serco driver.
While investigating a bug in the RHEL kernel, I noticed that the serial
console throughput is way below the configured speed of 115200 bps in
a HP Proliant DL380 Gen9. I was expecting something above 10KB/s, but
I got 2.5KB/s.
$ time ./sertest -n 2500 /tmp/serco
real 0m0.997s
user 0m0.000s
sys 0m0.997s
With the help of the function tracer, I then noticed the serial
controller was taking around 410us seconds to dispatch one single byte:
$ trace-cmd record -p function_graph -g serial8250_console_write \
./sertest -n 1 /tmp/serco
$ trace-cmd report
| serial8250_console_write() {
0.384 us | _raw_spin_lock_irqsave();
1.836 us | io_serial_in();
1.667 us | io_serial_out();
| uart_console_write() {
| serial8250_console_putchar() {
| wait_for_xmitr() {
1.870 us | io_serial_in();
2.238 us | }
1.737 us | io_serial_out();
4.318 us | }
4.675 us | }
| wait_for_xmitr() {
1.635 us | io_serial_in();
| __const_udelay() {
1.125 us | delay_tsc();
1.429 us | }
...
...
...
1.683 us | io_serial_in();
| __const_udelay() {
1.248 us | delay_tsc();
1.486 us | }
1.671 us | io_serial_in();
411.342 us | }
In another machine, I measured a throughput of 11.5KB/s, with the serial
controller taking between 80-90us to send each byte. That matches the
expected throughput for a configuration of 115200 bps.
This patch changes the serial8250_console_write to use the 16550 fifo
if available. In my benchmarks I got around 25% improvement in the slow
machine, and no performance penalty in the fast machine.
Signed-off-by: Wander Lairson Costa <wander@redhat.com>
---
drivers/tty/serial/8250/8250_port.c | 68 ++++++++++++++++++++++++++---
1 file changed, 62 insertions(+), 6 deletions(-)
diff --git a/drivers/tty/serial/8250/8250_port.c b/drivers/tty/serial/8250/8250_port.c
index 318af6f13605..8113e6c73407 100644
--- a/drivers/tty/serial/8250/8250_port.c
+++ b/drivers/tty/serial/8250/8250_port.c
@@ -2077,10 +2077,7 @@ static void serial8250_break_ctl(struct uart_port *port, int break_state)
serial8250_rpm_put(up);
}
-/*
- * Wait for transmitter & holding register to empty
- */
-static void wait_for_xmitr(struct uart_8250_port *up, int bits)
+static void wait_for_lsr(struct uart_8250_port *up, int bits)
{
unsigned int status, tmout = 10000;
@@ -2097,6 +2094,16 @@ static void wait_for_xmitr(struct uart_8250_port *up, int bits)
udelay(1);
touch_nmi_watchdog();
}
+}
+
+/*
+ * Wait for transmitter & holding register to empty
+ */
+static void wait_for_xmitr(struct uart_8250_port *up, int bits)
+{
+ unsigned int tmout;
+
+ wait_for_lsr(up, bits);
/* Wait up to 1s for flow control if necessary */
if (up->port.flags & UPF_CONS_FLOW) {
@@ -3332,6 +3339,35 @@ static void serial8250_console_restore(struct uart_8250_port *up)
serial8250_out_MCR(up, UART_MCR_DTR | UART_MCR_RTS);
}
+/*
+ * Print a string to the serial port using the device FIFO
+ *
+ * It sends fifosize bytes and then waits for the fifo
+ * to get empty.
+ */
+static void serial8250_console_fifo_write(struct uart_8250_port *up,
+ const char *s, unsigned int count)
+{
+ int i;
+ const char *end = s + count;
+ unsigned int fifosize = up->tx_loadsz;
+ bool cr_sent = false;
+
+ while (s != end) {
+ wait_for_lsr(up, UART_LSR_THRE);
+
+ for (i = 0; i < fifosize && s != end; ++i) {
+ if (*s == '\n' && !cr_sent) {
+ serial_out(up, UART_TX, '\r');
+ cr_sent = true;
+ } else {
+ serial_out(up, UART_TX, *s++);
+ cr_sent = false;
+ }
+ }
+ }
+}
+
/*
* Print a string to the serial port trying not to disturb
* any possible real use of the port...
@@ -3347,7 +3383,7 @@ void serial8250_console_write(struct uart_8250_port *up, const char *s,
struct uart_8250_em485 *em485 = up->em485;
struct uart_port *port = &up->port;
unsigned long flags;
- unsigned int ier;
+ unsigned int ier, use_fifo;
int locked = 1;
touch_nmi_watchdog();
@@ -3379,7 +3415,27 @@ void serial8250_console_write(struct uart_8250_port *up, const char *s,
mdelay(port->rs485.delay_rts_before_send);
}
- uart_console_write(port, s, count, serial8250_console_putchar);
+ use_fifo = (up->capabilities & UART_CAP_FIFO) &&
+ /*
+ * BCM283x requires to check the fifo
+ * after each byte.
+ */
+ !(up->capabilities & UART_CAP_MINI) &&
+ up->tx_loadsz > 1 &&
+ (up->fcr & UART_FCR_ENABLE_FIFO) &&
+ port->state &&
+ test_bit(TTY_PORT_INITIALIZED, &port->state->port.iflags) &&
+ /*
+ * After we put a data in the fifo, the controller will send
+ * it regardless of the CTS state. Therefore, only use fifo
+ * if we don't use control flow.
+ */
+ !(up->port.flags & UPF_CONS_FLOW);
+
+ if (likely(use_fifo))
+ serial8250_console_fifo_write(up, s, count);
+ else
+ uart_console_write(port, s, count, serial8250_console_putchar);
/*
* Finally, wait for transmitter to become empty
--
2.35.1
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v6] serial/8250: Use fifo in 8250 console driver
2022-04-01 19:46 ` [PATCH v6] " Wander Lairson Costa
@ 2022-04-04 9:32 ` Andy Shevchenko
2022-04-04 13:27 ` Wander Costa
0 siblings, 1 reply; 5+ messages in thread
From: Andy Shevchenko @ 2022-04-04 9:32 UTC (permalink / raw)
To: Wander Lairson Costa
Cc: Greg Kroah-Hartman, Jiri Slaby, Johan Hovold, Maciej W. Rozycki,
Lukas Wunner, Pali Rohár, open list:SERIAL DRIVERS,
open list, ilpo.jarvinen, rostedt, senozhatsky, andre.goddard,
sudipm.mukherjee, David.Laight, jonathanh, phil
On Fri, Apr 01, 2022 at 04:46:42PM -0300, Wander Lairson Costa wrote:
> Note: I am using a small test app + driver located at [0] for the
> problem description. serco is a driver whose write function dispatches
> to the serial controller. sertest is a user-mode app that writes n bytes
> to the serial console using the serco driver.
>
> While investigating a bug in the RHEL kernel, I noticed that the serial
> console throughput is way below the configured speed of 115200 bps in
> a HP Proliant DL380 Gen9. I was expecting something above 10KB/s, but
> I got 2.5KB/s.
>
> $ time ./sertest -n 2500 /tmp/serco
>
> real 0m0.997s
> user 0m0.000s
> sys 0m0.997s
>
> With the help of the function tracer, I then noticed the serial
> controller was taking around 410us seconds to dispatch one single byte:
>
> $ trace-cmd record -p function_graph -g serial8250_console_write \
> ./sertest -n 1 /tmp/serco
>
> $ trace-cmd report
>
> | serial8250_console_write() {
> 0.384 us | _raw_spin_lock_irqsave();
> 1.836 us | io_serial_in();
> 1.667 us | io_serial_out();
> | uart_console_write() {
> | serial8250_console_putchar() {
> | wait_for_xmitr() {
> 1.870 us | io_serial_in();
> 2.238 us | }
> 1.737 us | io_serial_out();
> 4.318 us | }
> 4.675 us | }
> | wait_for_xmitr() {
> 1.635 us | io_serial_in();
> | __const_udelay() {
> 1.125 us | delay_tsc();
> 1.429 us | }
> ...
> ...
> ...
> 1.683 us | io_serial_in();
> | __const_udelay() {
> 1.248 us | delay_tsc();
> 1.486 us | }
> 1.671 us | io_serial_in();
> 411.342 us | }
>
> In another machine, I measured a throughput of 11.5KB/s, with the serial
> controller taking between 80-90us to send each byte. That matches the
> expected throughput for a configuration of 115200 bps.
>
> This patch changes the serial8250_console_write to use the 16550 fifo
> if available. In my benchmarks I got around 25% improvement in the slow
> machine, and no performance penalty in the fast machine.
...
> + use_fifo = (up->capabilities & UART_CAP_FIFO) &&
> + /*
> + * BCM283x requires to check the fifo
> + * after each byte.
> + */
> + !(up->capabilities & UART_CAP_MINI) &&
Perhaps you need to also comment why we are using tx_loadsz and not fifosize.
> + up->tx_loadsz > 1 &&
> + (up->fcr & UART_FCR_ENABLE_FIFO) &&
> + port->state &&
> + test_bit(TTY_PORT_INITIALIZED, &port->state->port.iflags) &&
> + /*
> + * After we put a data in the fifo, the controller will send
> + * it regardless of the CTS state. Therefore, only use fifo
> + * if we don't use control flow.
> + */
> + !(up->port.flags & UPF_CONS_FLOW);
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v6] serial/8250: Use fifo in 8250 console driver
2022-04-04 9:32 ` Andy Shevchenko
@ 2022-04-04 13:27 ` Wander Costa
2022-04-04 13:44 ` Andy Shevchenko
0 siblings, 1 reply; 5+ messages in thread
From: Wander Costa @ 2022-04-04 13:27 UTC (permalink / raw)
To: Andy Shevchenko
Cc: Wander Lairson Costa, Greg Kroah-Hartman, Jiri Slaby,
Johan Hovold, Maciej W. Rozycki, Lukas Wunner, Pali Rohár,
open list:SERIAL DRIVERS, open list, Ilpo Järvinen,
Steven Rostedt, Sergey Senozhatsky, André Goddard Rosa,
Sudip Mukherjee, David Laight, Jon Hunter, phil
On Mon, Apr 4, 2022 at 6:32 AM Andy Shevchenko
<andriy.shevchenko@linux.intel.com> wrote:
>
> On Fri, Apr 01, 2022 at 04:46:42PM -0300, Wander Lairson Costa wrote:
> > Note: I am using a small test app + driver located at [0] for the
> > problem description. serco is a driver whose write function dispatches
> > to the serial controller. sertest is a user-mode app that writes n bytes
> > to the serial console using the serco driver.
> >
> > While investigating a bug in the RHEL kernel, I noticed that the serial
> > console throughput is way below the configured speed of 115200 bps in
> > a HP Proliant DL380 Gen9. I was expecting something above 10KB/s, but
> > I got 2.5KB/s.
> >
> > $ time ./sertest -n 2500 /tmp/serco
> >
> > real 0m0.997s
> > user 0m0.000s
> > sys 0m0.997s
> >
> > With the help of the function tracer, I then noticed the serial
> > controller was taking around 410us seconds to dispatch one single byte:
> >
> > $ trace-cmd record -p function_graph -g serial8250_console_write \
> > ./sertest -n 1 /tmp/serco
> >
> > $ trace-cmd report
> >
> > | serial8250_console_write() {
> > 0.384 us | _raw_spin_lock_irqsave();
> > 1.836 us | io_serial_in();
> > 1.667 us | io_serial_out();
> > | uart_console_write() {
> > | serial8250_console_putchar() {
> > | wait_for_xmitr() {
> > 1.870 us | io_serial_in();
> > 2.238 us | }
> > 1.737 us | io_serial_out();
> > 4.318 us | }
> > 4.675 us | }
> > | wait_for_xmitr() {
> > 1.635 us | io_serial_in();
> > | __const_udelay() {
> > 1.125 us | delay_tsc();
> > 1.429 us | }
> > ...
> > ...
> > ...
> > 1.683 us | io_serial_in();
> > | __const_udelay() {
> > 1.248 us | delay_tsc();
> > 1.486 us | }
> > 1.671 us | io_serial_in();
> > 411.342 us | }
> >
> > In another machine, I measured a throughput of 11.5KB/s, with the serial
> > controller taking between 80-90us to send each byte. That matches the
> > expected throughput for a configuration of 115200 bps.
> >
> > This patch changes the serial8250_console_write to use the 16550 fifo
> > if available. In my benchmarks I got around 25% improvement in the slow
> > machine, and no performance penalty in the fast machine.
>
> ...
>
> > + use_fifo = (up->capabilities & UART_CAP_FIFO) &&
> > + /*
> > + * BCM283x requires to check the fifo
> > + * after each byte.
> > + */
> > + !(up->capabilities & UART_CAP_MINI) &&
>
> Perhaps you need to also comment why we are using tx_loadsz and not fifosize.
>
Maybe it is better to document their difference in the struct
declaration and not in a random usage.
[snip]
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v6] serial/8250: Use fifo in 8250 console driver
2022-04-04 13:27 ` Wander Costa
@ 2022-04-04 13:44 ` Andy Shevchenko
0 siblings, 0 replies; 5+ messages in thread
From: Andy Shevchenko @ 2022-04-04 13:44 UTC (permalink / raw)
To: Wander Costa
Cc: Wander Lairson Costa, Greg Kroah-Hartman, Jiri Slaby,
Johan Hovold, Maciej W. Rozycki, Lukas Wunner, Pali Rohár,
open list:SERIAL DRIVERS, open list, Ilpo Järvinen,
Steven Rostedt, Sergey Senozhatsky, André Goddard Rosa,
Sudip Mukherjee, David Laight, Jon Hunter, phil
On Mon, Apr 04, 2022 at 10:27:30AM -0300, Wander Costa wrote:
> On Mon, Apr 4, 2022 at 6:32 AM Andy Shevchenko
> <andriy.shevchenko@linux.intel.com> wrote:
> > On Fri, Apr 01, 2022 at 04:46:42PM -0300, Wander Lairson Costa wrote:
...
> > > + use_fifo = (up->capabilities & UART_CAP_FIFO) &&
> > > + /*
> > > + * BCM283x requires to check the fifo
> > > + * after each byte.
> > > + */
> > > + !(up->capabilities & UART_CAP_MINI) &&
> >
> > Perhaps you need to also comment why we are using tx_loadsz and not fifosize.
>
> Maybe it is better to document their difference in the struct
> declaration and not in a random usage.
Here, when one reads a code (as a non-familiar with the area), the use of
tx_loadsz confuses if one saw previously fifosize used somewhere. So, I agree
that it's good to document in the structure, but here it's also good to have
a comment to briefly hint the reader why this and not the other one is used.
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2022-04-04 13:45 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-04-01 19:46 [PATCH v6 0/1] serial/8250: Use fifo in 8250 console driver Wander Lairson Costa
2022-04-01 19:46 ` [PATCH v6] " Wander Lairson Costa
2022-04-04 9:32 ` Andy Shevchenko
2022-04-04 13:27 ` Wander Costa
2022-04-04 13:44 ` Andy Shevchenko
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).