serial/8250: Use fifo in 8250 console driver
v6 cover serial/8250: Use fifo in 8250 console driver
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/[email protected]/
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(-)
Signature · 1 line
2.35.1
PATCH v6 1/1 serial/8250: Use fifo in 8250 console driver
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.
--- drivers/tty/serial/8250/8250_port.c | 68 ++++++++++++++++++++++++++--- 1 file changed, 62 insertions(+), 6 deletions(-)
drivers/tty/serial/8250/8250_port.c +62 -6
@@ -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
Signature · 1 line
2.35.1
Quoted 58 lines · Wander Lairson Costa
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/sercoreal 0m0.997s user 0m0.000s sys 0m0.997sWith 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_writeto 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.
...
drivers/tty/serial/8250/8250_port.c void serial8250_console_write(struct uart_8250_port *up, const char *s, · line 3423
Quoted 6 lines
drivers/tty/serial/8250/8250_port.c +6
-0+ 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.
Quoted 10 lines
drivers/tty/serial/8250/8250_port.c +10
-0+ 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 );
Signature · 2 lines
With Best Regards, Andy Shevchenko
Quoted 63 lines · Andy Shevchenko
Quoted 58 lines · Wander Lairson Costa
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/sercoreal 0m0.997s user 0m0.000s sys 0m0.997sWith 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_writeto 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....
Quoted 9 lines
drivers/tty/serial/8250/8250_port.c void serial8250_console_write(struct uart_8250_port *up, const char *s, · line 3423
Quoted 6 lines
drivers/tty/serial/8250/8250_port.c +6
-0+ 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_loadszand not fifosize.
Maybe it is better to document their difference in the struct declaration and not in a random usage.
[snip]
Quoted 3 lines · Wander Costa
Quoted 1 line · Andy Shevchenko
On Fri, Apr 01, 2022 at 04:46:42PM -0300, Wander Lairson Costa wrote:
...
Quoted 11 lines
Quoted 8 lines
drivers/tty/serial/8250/8250_port.c void serial8250_console_write(struct uart_8250_port *up, const char *s, · line 3423
Quoted 6 lines
drivers/tty/serial/8250/8250_port.c +6
-0+ 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_loadszand 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.
Signature · 2 lines
With Best Regards, Andy Shevchenko