xhci: dbc: honor usb transfer size boundaries.

Treat each completed full size write to /dev/ttyDBC0 as a separate usb
transfer. Make sure the size of the TRBs matches the size of the tty
write by first queuing as many max packet size TRBs as possible up to
the last TRB which will be cut short to match the size of the tty write.

This solves an issue where userspace writes several transfers back to
back via /dev/ttyDBC0 into a kfifo before dbgtty can find available
request to turn that kfifo data into TRBs on the transfer ring.

The boundary between transfer was lost as xhci-dbgtty then turned
everyting in the kfifo into as many 'max packet size' TRBs as possible.

DbC would then send more data to the host than intended for that
transfer, causing host to issue a babble error.

Refuse to write more data to kfifo until previous tty write data is
turned into properly sized TRBs with data size boundaries matching tty
write size

Tested-by: Uday M Bhat <uday.m.bhat@intel.com>
Tested-by: Łukasz Bartosik <ukaszb@chromium.org>
Cc: stable@vger.kernel.org
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://lore.kernel.org/r/20241016140000.783905-5-mathias.nyman@linux.intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/usb/host/xhci-dbgcap.h b/drivers/usb/host/xhci-dbgcap.h
index 8ec813b6e9fda675217051516adcea534006622f..9dc8f4d8077cc424047d89de950cca11685c355c 100644 (file)
--- a/drivers/usb/host/xhci-dbgcap.h
+++ b/drivers/usb/host/xhci-dbgcap.h
@@ -110,6 +110,7 @@ struct dbc_port {
        struct tasklet_struct           push;
 
        struct list_head                write_pool;
+       unsigned int                    tx_boundary;
 
        bool                            registered;
 };

diff --git a/drivers/usb/host/xhci-dbgtty.c b/drivers/usb/host/xhci-dbgtty.c
index b8e78867e25a54f36a1fe06a7ad5b17381994cf3..d719c16ea30b57f8499d2f481386f3471403d301 100644 (file)
--- a/drivers/usb/host/xhci-dbgtty.c
+++ b/drivers/usb/host/xhci-dbgtty.c
@@ -24,6 +24,29 @@ static inline struct dbc_port *dbc_to_port(struct xhci_dbc *dbc)
        return dbc->priv;
 }
 
+static unsigned int
+dbc_kfifo_to_req(struct dbc_port *port, char *packet)
+{
+       unsigned int    len;
+
+       len = kfifo_len(&port->port.xmit_fifo);
+
+       if (len == 0)
+               return 0;
+
+       len = min(len, DBC_MAX_PACKET);
+
+       if (port->tx_boundary)
+               len = min(port->tx_boundary, len);
+
+       len = kfifo_out(&port->port.xmit_fifo, packet, len);
+
+       if (port->tx_boundary)
+               port->tx_boundary -= len;
+
+       return len;
+}
+
 static int dbc_start_tx(struct dbc_port *port)
        __releases(&port->port_lock)
        __acquires(&port->port_lock)
@@ -36,7 +59,7 @@ static int dbc_start_tx(struct dbc_port *port)
 
        while (!list_empty(pool)) {
                req = list_entry(pool->next, struct dbc_request, list_pool);
-               len = kfifo_out(&port->port.xmit_fifo, req->buf, DBC_MAX_PACKET);
+               len = dbc_kfifo_to_req(port, req->buf);
                if (len == 0)
                        break;
                do_tty_wake = true;
@@ -200,14 +223,32 @@ static ssize_t dbc_tty_write(struct tty_struct *tty, const u8 *buf,
 {
        struct dbc_port         *port = tty->driver_data;
        unsigned long           flags;
+       unsigned int            written = 0;
 
        spin_lock_irqsave(&port->port_lock, flags);
-       if (count)
-               count = kfifo_in(&port->port.xmit_fifo, buf, count);
-       dbc_start_tx(port);
+
+       /*
+        * Treat tty write as one usb transfer. Make sure the writes are turned
+        * into TRB request having the same size boundaries as the tty writes.
+        * Don't add data to kfifo before previous write is turned into TRBs
+        */
+       if (port->tx_boundary) {
+               spin_unlock_irqrestore(&port->port_lock, flags);
+               return 0;
+       }
+
+       if (count) {
+               written = kfifo_in(&port->port.xmit_fifo, buf, count);
+
+               if (written == count)
+                       port->tx_boundary = kfifo_len(&port->port.xmit_fifo);
+
+               dbc_start_tx(port);
+       }
+
        spin_unlock_irqrestore(&port->port_lock, flags);
 
-       return count;
+       return written;
 }
 
 static int dbc_tty_put_char(struct tty_struct *tty, u8 ch)
@@ -241,6 +282,10 @@ static unsigned int dbc_tty_write_room(struct tty_struct *tty)
 
        spin_lock_irqsave(&port->port_lock, flags);
        room = kfifo_avail(&port->port.xmit_fifo);
+
+       if (port->tx_boundary)
+               room = 0;
+
        spin_unlock_irqrestore(&port->port_lock, flags);
 
        return room;