<br>计算机爱好者<br>云计算<br>云存储<br>网络技术<br>非洲酋长<br>可爱的胖子<br>十年攻城狮

    qemu iso设备使用时，断开链接概率导致崩溃问题

    [busuanzi]
    字数统计: 1k字   |   阅读时长≈ 5分

    首先报错代码如下，assert的时候，status 并不是NAK

    1
    2
    3
    4
    5
    6
    7
    8
    9
    if (xfer->iso_xfer) {
        /* retry iso transfer */
        if (xhci_setup_packet(xfer) < 0) {
            return;
        }
        usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
        assert(xfer->packet.status != USB_RET_NAK);
        xhci_try_complete_packet(xfer);

    首先查看redirect代码，发现正常情况下iso请求，是不会置为NAK状态的，怀疑这个请求是失效的。
    基于之前对于qemu多线程可能引起问题的推断，继续查看core文件和代码尝试排查

    首先根据core文件，获取Endpoint信息

    可以看到Endpoint 对应的type是255,说明是已经失效的Ednpoint
    通过Endpoint，获取device信息

    强制转化为重定向设备， 可以查到设备是0d8c:0014一个音频设备（vid=3468，pid=20）

    再回过头来分析出错代码
    在线程1中，从epctx中取retry指向的xfer，并对其进行重试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    static void xhci_kick_epctx(XHCIEPContext *epctx, unsigned int streamid)
    {
        XHCIState *xhci = epctx->xhci;
        //...

        if (epctx->retry) {
            XHCITransfer *xfer = epctx->retry;
            //...
            if (xfer->iso_xfer) {
                /* retry iso transfer */
                if (xhci_setup_packet(xfer) < 0) {
                    return;
                }
                usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
                assert(xfer->packet.status != USB_RET_NAK);
                xhci_try_complete_packet(xfer);
            } else {
            //...
            }
            //...
        }
        //...
    }

    线程2中，收到来自客户端的请求，请求断开连接
    其中代码，先进行detach操作
    再进行usbredir_init_endpoints，这个操作，是唯一一个会把工作中的endpoint置为type是255的地方

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    static void usbredir_device_disconnect(void *priv)
    {
        //...
        if (dev->dev.attached) {
            DPRINTF("detaching device\n");
            usb_device_detach(&dev->dev);
            //...
        }

        //...
        usbredir_init_endpoints(dev);
        //...
    }

    所以，如果xhci的detach操作，没能达到下面任意一个，就有可能出问题

    • 停止xhci_kick_epctx操作
    • 清空retry节点下的xfer
    • 必须保证在usbredir_init_endpoints之前执行完前面的

    下面先来看detach做了什么

    1
    2
    3
    4
    5
    6
    7
    8
    static void xhci_detach(USBPort *usbport)
    {
        XHCIState *xhci = usbport->opaque;
        XHCIPort *port = xhci_lookup_port(xhci, usbport);

        xhci_detach_slot(xhci, usbport);
        xhci_port_update(port, 1);
    }

    可以看到分别作了xhci_detach_slot和xhci_port_update两件事

    先看 xhci_detach_slot

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    /* cleanup slot state on usb device detach */
    static void xhci_detach_slot(XHCIState *xhci, USBPort *uport)
    {
        int slot, ep;

        for (slot = 0; slot < xhci->numslots; slot++) {
            if (xhci->slots[slot].uport == uport) {
                break;
            }
        }
        if (slot == xhci->numslots) {
            return;
        }

        for (ep = 0; ep < 31; ep++) {
            if (xhci->slots[slot].eps[ep]) {
                xhci_ep_nuke_xfers(xhci, slot + 1, ep + 1, 0);
            }
        }
        xhci->slots[slot].uport = NULL;
    }

    static int xhci_ep_nuke_xfers(XHCIState *xhci, unsigned int slotid,
                                   unsigned int epid, TRBCCode report)
    {
        XHCISlot *slot;
        XHCIEPContext *epctx;
        XHCITransfer *xfer;
        int killed = 0;
        USBEndpoint *ep = NULL;
        assert(slotid >= 1 && slotid <= xhci->numslots);
        assert(epid >= 1 && epid <= 31);

        DPRINTF("xhci_ep_nuke_xfers(%d, %d)\n", slotid, epid);

        slot = &xhci->slots[slotid-1];

        if (!slot->eps[epid-1]) {
            return 0;
        }

        epctx = slot->eps[epid-1];

        for (;;) {
            xfer = QTAILQ_FIRST(&epctx->transfers);
            if (xfer == NULL) {
                break;
            }
            killed += xhci_ep_nuke_one_xfer(xfer, report);
            if (killed) {
                report = 0; /* Only report once */
            }
            xhci_ep_free_xfer(xfer);
        }

        ep = xhci_epid_to_usbep(epctx);
        if (ep) {
            usb_device_ep_stopped(ep->dev, ep);
        }
        return killed;
    }

    可以明显看到释放 epctx->transfers 下的xfer
    下面就确认epctx->transfers 和epctx->retry是否有交集

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    static XHCITransfer *xhci_ep_alloc_xfer(XHCIEPContext *epctx,
                                            uint32_t length)
    {
        uint32_t limit = epctx->nr_pstreams + 16;
        XHCITransfer *xfer;

        if (epctx->xfer_count >= limit) {
            return NULL;
        }

        xfer = g_new0(XHCITransfer, 1);
        xfer->epctx = epctx;
        xfer->trbs = g_new(XHCITRB, length);
        xfer->trb_count = length;
        usb_packet_init(&xfer->packet);

        QTAILQ_INSERT_TAIL(&epctx->transfers, xfer, next);
        epctx->xfer_count++;

        return xfer;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    static void xhci_kick_epctx(XHCIEPContext *epctx, unsigned int streamid)
    {
        //...
        while (1) {
            //...
            xfer = xhci_ep_alloc_xfer(epctx, length);
            if (xfer == NULL) {
                break;
            }

            //...
            if (xfer != NULL && xfer->running_retry) {
                DPRINTF("xhci: xfer nacked, stopping schedule\n");
                epctx->retry = xfer;
                xhci_xfer_unmap(xfer);
                break;
            }
        }
        //...
    }

    还是这个函数xhci_kick_epctx
    可以看到retry 指向的是xhci_ep_alloc_xfer 申请出来的xfer，实际上就是transfers链下面的

    由此可见，至少retry指向的节点是被释放了的，但是retry自身却暂时还没找到设置为NULL的地方

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    static int xhci_ep_nuke_one_xfer(XHCITransfer *t, TRBCCode report)
    {
        //...
        if (t->running_retry) {
            if (t->epctx) {
                t->epctx->retry = NULL;
                timer_del(t->epctx->kick_timer);
            }
            t->running_retry = 0;
            killed = 1;
        }
        //...
    }

    除了xhci_kick_epctx自身之外，只在这里找到了retry的NULL设置
    会过头来再看函数调用，发现detach的时候有调用，说明是释放了的。

    • xhci_detach
      • xhci_detach_slot
        • xhci_ep_nuke_xfers
          • xhci_ep_nuke_one_xfer

    那么问题原因就清楚了，应该是因为多线程导致
    xhci_kick_epctx执行过程中，已经获取了retry指向的xfer
    线程切换到disconnect，调用xhci_detach函数导致xfer失效
    继续切会xhci_kick_epctx，对xfer进行操作，导致访问非法指针中的无效数据出错