Commit 658575b0 authored by Hugo Villeneuve's avatar Hugo Villeneuve Committed by Zhao Yipeng
Browse files

serial: sc16is7xx: fix TX fifo corruption 

mainline inclusion
from mainline-v6.11-rc3
commit 133f4c00b8b2bfcacead9b81e7e8edfceb4b06c4
category: bugfix
bugzilla: https://gitee.com/src-openeuler/kernel/issues/IAOXYG
CVE: CVE-2024-44951

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=133f4c00b8b2bfcacead9b81e7e8edfceb4b06c4



--------------------------------

serial: sc16is7xx: fix TX fifo corruption

Sometimes, when a packet is received on channel A at almost the same time
as a packet is about to be transmitted on channel B, we observe with a
logic analyzer that the received packet on channel A is transmitted on
channel B. In other words, the Tx buffer data on channel B is corrupted
with data from channel A.

The problem appeared since commit 4409df5866b7 ("serial: sc16is7xx: change
EFR lock to operate on each channels"), which changed the EFR locking to
operate on each channel instead of chip-wise.

This commit has introduced a regression, because the EFR lock is used not
only to protect the EFR registers access, but also, in a very obscure and
undocumented way, to protect access to the data buffer, which is shared by
the Tx and Rx handlers, but also by each channel of the IC.

Fix this regression first by switching to kfifo_out_linear_ptr() in
sc16is7xx_handle_tx() to eliminate the need for a shared Rx/Tx buffer.

Secondly, replace the chip-wise Rx buffer with a separate Rx buffer for
each channel.

Fixes: 4409df5866b7 ("serial: sc16is7xx: change EFR lock to operate on each channels")
Cc: stable@vger.kernel.org
Signed-off-by: default avatarHugo Villeneuve <hvilleneuve@dimonoff.com>
Link: https://lore.kernel.org/r/20240723125302.1305372-2-hugo@hugovil.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Conflicts:
	drivers/tty/serial/sc16is7xx.c
[The cause of the conflict comes from the prefix "1788cf6a91d9fa9aa61fc2917afe192c23d67f6a
tty: serial: switch from circ_buf to kfifo", which modifies a large number of files. After
analysis, only the changes of sc16is7xx.c are related to the fix patch, and the modifications
do not involve external interfaces. Therefore, only this part is merged to resolve the conflict.]
Signed-off-by: default avatarZhao Yipeng <zhaoyipeng5@huawei.com>
parent 2657df99

drivers/tty/serial/sc16is7xx.c

+24 −33
Original line number Diff line number Diff line
@@ -329,6 +329,7 @@ struct sc16is7xx_one { 
	struct kthread_work		reg_work;

	struct kthread_delayed_work	ms_work;

	struct sc16is7xx_one_config	config;

	unsigned char           buf[SC16IS7XX_FIFO_SIZE]; /* Rx buffer. */

	bool				irda_mode;

	unsigned int			old_mctrl;

};
@@ -341,7 +342,6 @@ struct sc16is7xx_port { 
	unsigned long			gpio_valid_mask;

#endif

	u8				mctrl_mask;

	unsigned char			buf[SC16IS7XX_FIFO_SIZE];

	struct kthread_worker		kworker;

	struct task_struct		*kworker_task;

	struct sc16is7xx_one		p[];
@@ -566,18 +566,18 @@ static int sc16is7xx_set_baud(struct uart_port *port, int baud) 
static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen,

				unsigned int iir)

{

	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);

	struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);

	unsigned int lsr = 0, bytes_read, i;

	bool read_lsr = (iir == SC16IS7XX_IIR_RLSE_SRC) ? true : false;

	u8 ch, flag;



	if (unlikely(rxlen >= sizeof(s->buf))) {

	if (unlikely(rxlen >= sizeof(one->buf))) {

		dev_warn_ratelimited(port->dev,

				     "ttySC%i: Possible RX FIFO overrun: %d\n",

				     port->line, rxlen);

		port->icount.buf_overrun++;

		/* Ensure sanity of RX level */

		rxlen = sizeof(s->buf);

		rxlen = sizeof(one->buf);

	}



	while (rxlen) {
@@ -590,10 +590,10 @@ static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen, 
			lsr = 0;



		if (read_lsr) {

			s->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);

			one->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);

			bytes_read = 1;

		} else {

			sc16is7xx_fifo_read(port, s->buf, rxlen);

			sc16is7xx_fifo_read(port, one->buf, rxlen);

			bytes_read = rxlen;

		}
@@ -626,7 +626,7 @@ static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen, 
		}



		for (i = 0; i < bytes_read; ++i) {

			ch = s->buf[i];

			ch = one->buf[i];

			if (uart_handle_sysrq_char(port, ch))

				continue;
@@ -644,10 +644,10 @@ static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen, 


static void sc16is7xx_handle_tx(struct uart_port *port)

{

	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);

	struct circ_buf *xmit = &port->state->xmit;

	unsigned int txlen, to_send, i;

	struct tty_port *tport = &port->state->port;

	unsigned long flags;

	unsigned int txlen;

	unsigned char *tail;



	if (unlikely(port->x_char)) {

		sc16is7xx_port_write(port, SC16IS7XX_THR_REG, port->x_char);
@@ -656,17 +656,14 @@ static void sc16is7xx_handle_tx(struct uart_port *port) 
		return;

	}



	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {

	if (kfifo_is_empty(&tport->xmit_fifo) || uart_tx_stopped(port)) {

		uart_port_lock_irqsave(port, &flags);

		sc16is7xx_stop_tx(port);

		uart_port_unlock_irqrestore(port, flags);

		return;

	}



	/* Get length of data pending in circular buffer */

	to_send = uart_circ_chars_pending(xmit);

	if (likely(to_send)) {

		/* Limit to size of TX FIFO */

	/* Limit to space available in TX FIFO */

	txlen = sc16is7xx_port_read(port, SC16IS7XX_TXLVL_REG);

	if (txlen > SC16IS7XX_FIFO_SIZE) {

		dev_err_ratelimited(port->dev,
@@ -674,22 +671,16 @@ static void sc16is7xx_handle_tx(struct uart_port *port) 
			txlen, SC16IS7XX_FIFO_SIZE);

		txlen = 0;

	}

		to_send = (to_send > txlen) ? txlen : to_send;



		/* Convert to linear buffer */

		for (i = 0; i < to_send; ++i) {

			s->buf[i] = xmit->buf[xmit->tail];

			uart_xmit_advance(port, 1);

		}



		sc16is7xx_fifo_write(port, s->buf, to_send);

	}

	txlen = kfifo_out_linear_ptr(&tport->xmit_fifo, &tail, txlen);

	sc16is7xx_fifo_write(port, tail, txlen);

	uart_xmit_advance(port, txlen);



	uart_port_lock_irqsave(port, &flags);

	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)

	if (kfifo_len(&tport->xmit_fifo) < WAKEUP_CHARS)

		uart_write_wakeup(port);



	if (uart_circ_empty(xmit))

	if (kfifo_is_empty(&tport->xmit_fifo))

		sc16is7xx_stop_tx(port);

	else

		sc16is7xx_ier_set(port, SC16IS7XX_IER_THRI_BIT);