From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6DF4FC433F5 for ; Fri, 15 Oct 2021 04:24:01 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 146FF61056 for ; Fri, 15 Oct 2021 04:24:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 146FF61056 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id A748683B27; Fri, 15 Oct 2021 04:24:00 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id xW1XYIVYW46v; Fri, 15 Oct 2021 04:23:59 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp1.osuosl.org (Postfix) with ESMTPS id 5FD1483B22; Fri, 15 Oct 2021 04:23:58 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 10033C0011; Fri, 15 Oct 2021 04:23:58 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 7A776C000D for ; Fri, 15 Oct 2021 04:23:56 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 5CF76400C4 for ; Fri, 15 Oct 2021 04:23:56 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp2.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id rR444yQaJw2s for ; Fri, 15 Oct 2021 04:23:54 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by smtp2.osuosl.org (Postfix) with ESMTPS id 531B640001 for ; Fri, 15 Oct 2021 04:23:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1634271833; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Pig5QQjVrOL79mVmltr3kqNBr5fnBI51DbefzTjWym4=; b=cGFD+tJ+QQILJ1O2VOSErL96Xnz6rP/G2maKVM5i7vnlJIZHX+EjuUndaFQR+Xgzxz4gKv dN02z+6MmKase56eYMgysvbDB3E0fAGgTtIlOgvfdJf5JGrgZGJkKVYr2OqDGS87QIQJjN q/eyg3yNc7g0bXYR5j9u3a92y+GcQxI= Received: from mail-pj1-f70.google.com (mail-pj1-f70.google.com [209.85.216.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-141-R-L-Sx0aN7y3cqzha_UI3Q-1; Fri, 15 Oct 2021 00:23:50 -0400 X-MC-Unique: R-L-Sx0aN7y3cqzha_UI3Q-1 Received: by mail-pj1-f70.google.com with SMTP id lw18-20020a17090b181200b001a10ecde3d3so1206578pjb.4 for ; Thu, 14 Oct 2021 21:23:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=Pig5QQjVrOL79mVmltr3kqNBr5fnBI51DbefzTjWym4=; b=g0nrrfA0KM5Qntyv6rnfimKE6vhLWcT5d4whiZHsCblmSXbMJTWIpDAL8rC9gAhFQt zLql4ojnNUAtCfdQKkC3XwJvADQ2QIqIsJjIMLAbhwqNfgtakQl4oKM7qTrzgHEbqaLX 17vMBLtKrjIlFx/K5J41BiToetWHW5Jt3ew98rGY8fLH9b+8WPACMXVI4X31aRMkkPEP VaZkM2dbxT6gAj8fBwfwVr6p9n4uSMd3zoK0LZd+rf6NFevSLAd3eU0G/yON4YkzhlUy sZuaITLcRWHsR04j9NVljIfefuUS2jpL8Oj8Z/paEOfgYNQ9M6nDpo8Es14PaYuKcn0s xLFQ== X-Gm-Message-State: AOAM532kaEZkVb1gafG1o3Yu1BYiSKY3jbhRuRfEEH6qCfptz7NE0goH 1APNZVd1tLg7Qnxvcv/oSSRs7H6otIHe0G8Ruzb0jegQaigoGFNbUirtrXtlFFCcHkY6HQ9nAym n++04cxU1nGDfylaCUhzZpjk61tVfiN7oyjXOMRBEzA== X-Received: by 2002:a17:90b:694:: with SMTP id m20mr25430437pjz.160.1634271829229; Thu, 14 Oct 2021 21:23:49 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx9n9i6yJF6XnyAqRct9MWJATebG3DewQia8hyd/kJcrCrCDQRCnDHh59SsouEUkbLh+rP+TA== X-Received: by 2002:a17:90b:694:: with SMTP id m20mr25430381pjz.160.1634271828646; Thu, 14 Oct 2021 21:23:48 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id f20sm3611793pga.12.2021.10.14.21.23.43 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 14 Oct 2021 21:23:48 -0700 (PDT) Subject: Re: [RFC PATCH v4 15/20] vhost: Shadow virtqueue buffers forwarding To: Eugenio Perez Martin References: <20211001070603.307037-1-eperezma@redhat.com> <20211001070603.307037-16-eperezma@redhat.com> From: Jason Wang Message-ID: Date: Fri, 15 Oct 2021 12:23:42 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.14.0 MIME-Version: 1.0 In-Reply-To: Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: Parav Pandit , Markus Armbruster , "Michael S. Tsirkin" , qemu-level , virtualization , Harpreet Singh Anand , Xiao W Wang , Stefan Hajnoczi , Eli Cohen , Eric Blake , Michael Lilja X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CuWcqCAyMDIxLzEwLzE1IOS4iuWNiDE6NTYsIEV1Z2VuaW8gUGVyZXogTWFydGluIOWGmemBkzoK PiBPbiBXZWQsIE9jdCAxMywgMjAyMSBhdCA2OjMxIEFNIEphc29uIFdhbmcgPGphc293YW5nQHJl ZGhhdC5jb20+IHdyb3RlOgo+Pgo+PiDlnKggMjAyMS8xMC8xIOS4i+WNiDM6MDUsIEV1Z2VuaW8g UMOpcmV6IOWGmemBkzoKPj4+IEluaXRpYWwgdmVyc2lvbiBvZiBzaGFkb3cgdmlydHF1ZXVlIHRo YXQgYWN0dWFsbHkgZm9yd2FyZCBidWZmZXJzLiBUaGVyZQo+Pj4gYXJlIG5vIGlvbW11IHN1cHBv cnQgYXQgdGhlIG1vbWVudCwgYW5kIHRoYXQgd2lsbCBiZSBhZGRyZXNzZWQgaW4gZnV0dXJlCj4+ PiBwYXRjaGVzIG9mIHRoaXMgc2VyaWVzLiBTaW5jZSBhbGwgdmhvc3QtdmRwYSBkZXZpY2VzIHVz ZXMgZm9yY2VkIElPTU1VLAo+Pj4gdGhpcyBtZWFucyB0aGF0IFNWUSBpcyBub3QgdXNhYmxlIGF0 IHRoaXMgcG9pbnQgb2YgdGhlIHNlcmllcyBvbiBhbnkKPj4+IGRldmljZS4KPj4+Cj4+PiBGb3Ig c2ltcGxpY2l0eSBpdCBvbmx5IHN1cHBvcnRzIG1vZGVybiBkZXZpY2VzLCB0aGF0IGV4cGVjdHMg dnJpbmcKPj4+IGluIGxpdHRsZSBlbmRpYW4sIHdpdGggc3BsaXQgcmluZyBhbmQgbm8gZXZlbnQg aWR4IG9yIGluZGlyZWN0Cj4+PiBkZXNjcmlwdG9ycy4gU3VwcG9ydCBmb3IgdGhlbSB3aWxsIG5v dCBiZSBhZGRlZCBpbiB0aGlzIHNlcmllcy4KPj4+Cj4+PiBJdCByZXVzZXMgdGhlIFZpcnRRdWV1 ZSBjb2RlIGZvciB0aGUgZGV2aWNlIHBhcnQuIFRoZSBkcml2ZXIgcGFydCBpcwo+Pj4gYmFzZWQg b24gTGludXgncyB2aXJ0aW9fcmluZyBkcml2ZXIsIGJ1dCB3aXRoIHN0cmlwcGVkIGZ1bmN0aW9u YWxpdHkKPj4+IGFuZCBvcHRpbWl6YXRpb25zIHNvIGl0J3MgZWFzaWVyIHRvIHJldmlldy4gTGF0 ZXIgY29tbWl0cyBhZGQgc2ltcGxlcgo+Pj4gb25lcy4KPj4+Cj4+PiBTVlEgdXNlcyBWSVJUSU9f Q09ORklHX1NfREVWSUNFX1NUT1BQRUQgdG8gcGF1c2UgdGhlIGRldmljZSBhbmQKPj4+IHJldHJp ZXZlIGl0cyBzdGF0dXMgKG5leHQgYXZhaWxhYmxlIGlkeCB0aGUgZGV2aWNlIHdhcyBnb2luZyB0 bwo+Pj4gY29uc3VtZSkgcmFjZS1mcmVlLiBJdCBjYW4gbGF0ZXIgcmVzZXQgdGhlIGRldmljZSB0 byByZXBsYWNlIHZyaW5nCj4+PiBhZGRyZXNzZXMgZXRjLiBXaGVuIFNWUSBzdGFydHMgcWVtdSBj YW4gcmVzdW1lIGNvbnN1bWluZyB0aGUgZ3Vlc3Qncwo+Pj4gZHJpdmVyIHJpbmcgZnJvbSB0aGF0 IHN0YXRlLCB3aXRob3V0IG5vdGljZSBmcm9tIHRoZSBsYXR0ZXIuCj4+Pgo+Pj4gVGhpcyBzdGF0 dXMgYml0IFZJUlRJT19DT05GSUdfU19ERVZJQ0VfU1RPUFBFRCBpcyBjdXJyZW50bHkgZGlzY3Vz c2VkCj4+PiBpbiBWaXJ0SU8sIGFuZCBpcyBpbXBsZW1lbnRlZCBpbiBxZW11IFZpcnRJTy1uZXQg ZGV2aWNlcyBpbiBwcmV2aW91cwo+Pj4gY29tbWl0cy4KPj4+Cj4+PiBSZW1vdmFsIG9mIF9TX0RF VklDRV9TVE9QUEVEIGJpdCAoaW4gb3RoZXIgd29yZHMsIHJlc3VtaW5nIHRoZSBkZXZpY2UpCj4+ PiBjYW4gYmUgZG9uZSBpbiB0aGUgZnV0dXJlIGlmIGFuIHVzZSBjYXNlIGFyaXNlcy4gQXQgdGhp cyBtb21lbnQgd2UgY2FuCj4+PiBqdXN0IHJlbHkgb24gcmVzZXRpbmcgdGhlIGZ1bGwgZGV2aWNl Lgo+Pj4KPj4+IFNpZ25lZC1vZmYtYnk6IEV1Z2VuaW8gUMOpcmV6IDxlcGVyZXptYUByZWRoYXQu Y29tPgo+Pj4gLS0tCj4+PiAgICBxYXBpL25ldC5qc29uICAgICAgICAgICAgICAgICAgICAgIHwg ICAyICstCj4+PiAgICBody92aXJ0aW8vdmhvc3Qtc2hhZG93LXZpcnRxdWV1ZS5jIHwgMjM3ICsr KysrKysrKysrKysrKysrKysrKysrKysrKystCj4+PiAgICBody92aXJ0aW8vdmhvc3QtdmRwYS5j ICAgICAgICAgICAgIHwgMTA5ICsrKysrKysrKysrKy0KPj4+ICAgIDMgZmlsZXMgY2hhbmdlZCwg MzM3IGluc2VydGlvbnMoKyksIDExIGRlbGV0aW9ucygtKQo+Pj4KPj4+IGRpZmYgLS1naXQgYS9x YXBpL25ldC5qc29uIGIvcWFwaS9uZXQuanNvbgo+Pj4gaW5kZXggZmU1NDZiMGU3Yy4uMWY0YTU1 ZjJjNSAxMDA2NDQKPj4+IC0tLSBhL3FhcGkvbmV0Lmpzb24KPj4+ICsrKyBiL3FhcGkvbmV0Lmpz b24KPj4+IEBAIC04Niw3ICs4Niw3IEBACj4+PiAgICAjCj4+PiAgICAjIEBuYW1lOiB0aGUgZGV2 aWNlIG5hbWUgb2YgdGhlIFZpcnRJTyBkZXZpY2UKPj4+ICAgICMKPj4+IC0jIEBlbmFibGU6IHRy dWUgdG8gdXNlIHRoZSBhbHRlcm5hdGUgc2hhZG93IFZRIG5vdGlmaWNhdGlvbnMKPj4+ICsjIEBl bmFibGU6IHRydWUgdG8gdXNlIHRoZSBhbHRlcm5hdGUgc2hhZG93IFZRIGJ1ZmZlcnMgZm93YXJk aW5nIHBhdGgKPj4+ICAgICMKPj4+ICAgICMgUmV0dXJuczogRXJyb3IgaWYgZmFpbHVyZSwgb3Ig J25vIGVycm9yJyBmb3Igc3VjY2Vzcy4KPj4+ICAgICMKPj4+IGRpZmYgLS1naXQgYS9ody92aXJ0 aW8vdmhvc3Qtc2hhZG93LXZpcnRxdWV1ZS5jIGIvaHcvdmlydGlvL3Zob3N0LXNoYWRvdy12aXJ0 cXVldWUuYwo+Pj4gaW5kZXggMzRlMTU5ZDRmZC4uZGY3ZTZmYTNlYyAxMDA2NDQKPj4+IC0tLSBh L2h3L3ZpcnRpby92aG9zdC1zaGFkb3ctdmlydHF1ZXVlLmMKPj4+ICsrKyBiL2h3L3ZpcnRpby92 aG9zdC1zaGFkb3ctdmlydHF1ZXVlLmMKPj4+IEBAIC0xMCw2ICsxMCw3IEBACj4+PiAgICAjaW5j bHVkZSAicWVtdS9vc2RlcC5oIgo+Pj4gICAgI2luY2x1ZGUgImh3L3ZpcnRpby92aG9zdC1zaGFk b3ctdmlydHF1ZXVlLmgiCj4+PiAgICAjaW5jbHVkZSAiaHcvdmlydGlvL3Zob3N0LmgiCj4+PiAr I2luY2x1ZGUgImh3L3ZpcnRpby92aXJ0aW8tYWNjZXNzLmgiCj4+Pgo+Pj4gICAgI2luY2x1ZGUg InN0YW5kYXJkLWhlYWRlcnMvbGludXgvdmhvc3RfdHlwZXMuaCIKPj4+Cj4+PiBAQCAtNDQsMTUg KzQ1LDEzNSBAQCB0eXBlZGVmIHN0cnVjdCBWaG9zdFNoYWRvd1ZpcnRxdWV1ZSB7Cj4+Pgo+Pj4g ICAgICAgIC8qIFZpcnRpbyBkZXZpY2UgKi8KPj4+ICAgICAgICBWaXJ0SU9EZXZpY2UgKnZkZXY7 Cj4+PiArCj4+PiArICAgIC8qIE1hcCBmb3IgcmV0dXJuaW5nIGd1ZXN0J3MgZGVzY3JpcHRvcnMg Ki8KPj4+ICsgICAgVmlydFF1ZXVlRWxlbWVudCAqKnJpbmdfaWRfbWFwczsKPj4+ICsKPj4+ICsg ICAgLyogTmV4dCBoZWFkIHRvIGV4cG9zZSB0byBkZXZpY2UgKi8KPj4+ICsgICAgdWludDE2X3Qg YXZhaWxfaWR4X3NoYWRvdzsKPj4+ICsKPj4+ICsgICAgLyogTmV4dCBmcmVlIGRlc2NyaXB0b3Ig Ki8KPj4+ICsgICAgdWludDE2X3QgZnJlZV9oZWFkOwo+Pj4gKwo+Pj4gKyAgICAvKiBMYXN0IHNl ZW4gdXNlZCBpZHggKi8KPj4+ICsgICAgdWludDE2X3Qgc2hhZG93X3VzZWRfaWR4Owo+Pj4gKwo+ Pj4gKyAgICAvKiBOZXh0IGhlYWQgdG8gY29uc3VtZSBmcm9tIGRldmljZSAqLwo+Pj4gKyAgICB1 aW50MTZfdCB1c2VkX2lkeDsKPj4KPj4gTGV0J3MgdXNlICJsYXN0X3VzZWRfaWR4IiBhcyBrZXJu ZWwgZHJpdmVyIGRpZC4KPj4KPiBPayBJIHdpbGwgY2hhbmdlIGl0Lgo+Cj4+PiAgICB9IFZob3N0 U2hhZG93VmlydHF1ZXVlOwo+Pj4KPj4+ICAgIC8qIElmIHRoZSBkZXZpY2UgaXMgdXNpbmcgc29t ZSBvZiB0aGVzZSwgU1ZRIGNhbm5vdCBjb21tdW5pY2F0ZSAqLwo+Pj4gICAgYm9vbCB2aG9zdF9z dnFfdmFsaWRfZGV2aWNlX2ZlYXR1cmVzKHVpbnQ2NF90ICpkZXZfZmVhdHVyZXMpCj4+PiAgICB7 Cj4+PiAtICAgIHJldHVybiB0cnVlOwo+Pj4gKyAgICB1aW50NjRfdCBiOwo+Pj4gKyAgICBib29s IHIgPSB0cnVlOwo+Pj4gKwo+Pj4gKyAgICBmb3IgKGIgPSBWSVJUSU9fVFJBTlNQT1JUX0ZfU1RB UlQ7IGIgPD0gVklSVElPX1RSQU5TUE9SVF9GX0VORDsgKytiKSB7Cj4+PiArICAgICAgICBzd2l0 Y2ggKGIpIHsKPj4+ICsgICAgICAgIGNhc2UgVklSVElPX0ZfTk9USUZZX09OX0VNUFRZOgo+Pj4g KyAgICAgICAgY2FzZSBWSVJUSU9fRl9BTllfTEFZT1VUOgo+Pj4gKyAgICAgICAgICAgIC8qIFNW USBpcyBmaW5lIHdpdGggdGhpcyBmZWF0dXJlICovCj4+PiArICAgICAgICAgICAgY29udGludWU7 Cj4+PiArCj4+PiArICAgICAgICBjYXNlIFZJUlRJT19GX0FDQ0VTU19QTEFURk9STToKPj4+ICsg ICAgICAgICAgICAvKiBTVlEgbmVlZHMgdGhpcyBmZWF0dXJlIGRpc2FibGVkLiBDYW4ndCBjb250 aW51ZSAqLwo+Pgo+PiBTbyBjb2RlIGNhbiBleHBsYWluIGl0c2VsZiwgbmVlZCBhIGNvbW1lbnQg dG8gZXhwbGFpbiB3aHkuCj4+Cj4gRG8geW91IG1lYW4gdGhhdCBpdCAqZG9lc24ndCogbmVlZCBh IGNvbW1lbnQgdG8gZXhwbGFpbiB3aHk/IEluIHRoYXQKPiBjYXNlIEkgd2lsbCBkZWxldGUgdGhl bS4KCgpJIG1lYW50IHRoZSBjb21tZW50IGlzIGR1cGxpY2F0ZWQgd2l0aCB0aGUgY29kZS4gSWYg eW91IHdpc2gsIHlvdSBjYW4gCmV4cGxhaW4gd2h5IEFDQ0VTU19QTEFURk9STSBuZWVkcyB0byBi ZSBkaXNhYmxlZC4KCgo+Cj4+PiArICAgICAgICAgICAgaWYgKCpkZXZfZmVhdHVyZXMgJiBCSVRf VUxMKGIpKSB7Cj4+PiArICAgICAgICAgICAgICAgIGNsZWFyX2JpdChiLCBkZXZfZmVhdHVyZXMp Owo+Pj4gKyAgICAgICAgICAgICAgICByID0gZmFsc2U7Cj4+PiArICAgICAgICAgICAgfQo+Pj4g KyAgICAgICAgICAgIGJyZWFrOwo+Pj4gKwo+Pj4gKyAgICAgICAgY2FzZSBWSVJUSU9fRl9WRVJT SU9OXzE6Cj4+PiArICAgICAgICAgICAgLyogU1ZRIG5lZWRzIHRoaXMgZmVhdHVyZSwgc28gY2Fu J3QgY29udGludWUgKi8KPj4KPj4gQSBjb21tZW50IHRvIGV4cGxhaW4gd2h5IFNWUSBuZWVkcyB0 aGlzIGZlYXR1cmUuCj4+Cj4gU3VyZSBJIHdpbGwgYWRkIGl0Lgo+Cj4+PiArICAgICAgICAgICAg aWYgKCEoKmRldl9mZWF0dXJlcyAmIEJJVF9VTEwoYikpKSB7Cj4+PiArICAgICAgICAgICAgICAg IHNldF9iaXQoYiwgZGV2X2ZlYXR1cmVzKTsKPj4+ICsgICAgICAgICAgICAgICAgciA9IGZhbHNl Owo+Pj4gKyAgICAgICAgICAgIH0KPj4+ICsgICAgICAgICAgICBjb250aW51ZTsKPj4+ICsKPj4+ ICsgICAgICAgIGRlZmF1bHQ6Cj4+PiArICAgICAgICAgICAgLyoKPj4+ICsgICAgICAgICAgICAg KiBTVlEgbXVzdCBkaXNhYmxlIHRoaXMgZmVhdHVyZSwgbGV0J3MgaG9wZSB0aGUgZGV2aWNlIGlz IGZpbmUKPj4+ICsgICAgICAgICAgICAgKiB3aXRob3V0IGl0Lgo+Pj4gKyAgICAgICAgICAgICAq Lwo+Pj4gKyAgICAgICAgICAgIGlmICgqZGV2X2ZlYXR1cmVzICYgQklUX1VMTChiKSkgewo+Pj4g KyAgICAgICAgICAgICAgICBjbGVhcl9iaXQoYiwgZGV2X2ZlYXR1cmVzKTsKPj4+ICsgICAgICAg ICAgICB9Cj4+PiArICAgICAgICB9Cj4+PiArICAgIH0KPj4+ICsKPj4+ICsgICAgcmV0dXJuIHI7 Cj4+PiArfQo+Pgo+PiBMZXQncyBtb3ZlIHRoaXMgdG8gcGF0Y2ggMTQuCj4+Cj4gSSBjYW4gbW92 ZSBpdCBkb3duIHRvIDE0LzIwLCBidXQgdGhlbiBpdCBpcyBub3QgcmVhbGx5IGFjY3VyYXRlLCBz aW5jZQo+IG5vdGlmaWNhdGlvbnMgZm9yd2FyZGluZyBjYW4gd29yayB3aXRoIGFsbCBmZWF0dXJl IHNldHMuIE5vdCBsaWtlIHdlCj4gYXJlIGludHJvZHVjaW5nIGEgcmVncmVzc2lvbiwgYnV0IHN0 aWxsLgo+Cj4gSSBjYW4gYWx3YXlzIGV4cGxhaW4gdGhhdCBpbiB0aGUgcGF0Y2ggbWVzc2FnZSB0 aG91Z2gsIHdvdWxkIHRoYXQgYmUgb2s/CgoKSSdtIGFmcmFpZCB0aGlzIHdpbGwgYnJlYWsgYmlz ZWN0aW9uLiBFLmcgZm9yIHBhdGNoIDE0LCBpdCB3b3JrcyBmb3IgYW55IApmZWF0dXJlcyBidXQg Zm9yIHBhdGNoIDE1IGl0IGRvZXNuJ3QuCgoKPgo+Pj4gKwo+Pj4gK3N0YXRpYyB2b2lkIHZob3N0 X3ZyaW5nX3dyaXRlX2Rlc2NzKFZob3N0U2hhZG93VmlydHF1ZXVlICpzdnEsCj4+PiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgc3RydWN0IGlvdmVjICppb3ZlYywK Pj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplX3QgbnVtLCBib29s IG1vcmVfZGVzY3MsIGJvb2wgd3JpdGUpCj4+PiArewo+Pj4gKyAgICB1aW50MTZfdCBpID0gc3Zx LT5mcmVlX2hlYWQsIGxhc3QgPSBzdnEtPmZyZWVfaGVhZDsKPj4+ICsgICAgdW5zaWduZWQgbjsK Pj4+ICsgICAgdWludDE2X3QgZmxhZ3MgPSB3cml0ZSA/IGNwdV90b19sZTE2KFZSSU5HX0RFU0Nf Rl9XUklURSkgOiAwOwo+Pj4gKyAgICB2cmluZ19kZXNjX3QgKmRlc2NzID0gc3ZxLT52cmluZy5k ZXNjOwo+Pj4gKwo+Pj4gKyAgICBpZiAobnVtID09IDApIHsKPj4+ICsgICAgICAgIHJldHVybjsK Pj4+ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICBmb3IgKG4gPSAwOyBuIDwgbnVtOyBuKyspIHsKPj4+ ICsgICAgICAgIGlmIChtb3JlX2Rlc2NzIHx8IChuICsgMSA8IG51bSkpIHsKPj4+ICsgICAgICAg ICAgICBkZXNjc1tpXS5mbGFncyA9IGZsYWdzIHwgY3B1X3RvX2xlMTYoVlJJTkdfREVTQ19GX05F WFQpOwo+Pj4gKyAgICAgICAgfSBlbHNlIHsKPj4+ICsgICAgICAgICAgICBkZXNjc1tpXS5mbGFn cyA9IGZsYWdzOwo+Pj4gKyAgICAgICAgfQo+Pj4gKyAgICAgICAgZGVzY3NbaV0uYWRkciA9IGNw dV90b19sZTY0KChod2FkZHIpaW92ZWNbbl0uaW92X2Jhc2UpOwo+Pj4gKyAgICAgICAgZGVzY3Nb aV0ubGVuID0gY3B1X3RvX2xlMzIoaW92ZWNbbl0uaW92X2xlbik7Cj4+PiArCj4+PiArICAgICAg ICBsYXN0ID0gaTsKPj4+ICsgICAgICAgIGkgPSBjcHVfdG9fbGUxNihkZXNjc1tpXS5uZXh0KTsK Pj4+ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICBzdnEtPmZyZWVfaGVhZCA9IGxlMTZfdG9fY3B1KGRl c2NzW2xhc3RdLm5leHQpOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgdW5zaWduZWQgdmhvc3Rf c3ZxX2FkZF9zcGxpdChWaG9zdFNoYWRvd1ZpcnRxdWV1ZSAqc3ZxLAo+Pj4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFZpcnRRdWV1ZUVsZW1lbnQgKmVsZW0pCj4+PiArewo+ Pj4gKyAgICBpbnQgaGVhZDsKPj4+ICsgICAgdW5zaWduZWQgYXZhaWxfaWR4Owo+Pj4gKyAgICB2 cmluZ19hdmFpbF90ICphdmFpbCA9IHN2cS0+dnJpbmcuYXZhaWw7Cj4+PiArCj4+PiArICAgIGhl YWQgPSBzdnEtPmZyZWVfaGVhZDsKPj4+ICsKPj4+ICsgICAgLyogV2UgbmVlZCBzb21lIGRlc2Ny aXB0b3JzIGhlcmUgKi8KPj4+ICsgICAgYXNzZXJ0KGVsZW0tPm91dF9udW0gfHwgZWxlbS0+aW5f bnVtKTsKPj4+ICsKPj4+ICsgICAgdmhvc3RfdnJpbmdfd3JpdGVfZGVzY3Moc3ZxLCBlbGVtLT5v dXRfc2csIGVsZW0tPm91dF9udW0sCj4+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVs ZW0tPmluX251bSA+IDAsIGZhbHNlKTsKPj4+ICsgICAgdmhvc3RfdnJpbmdfd3JpdGVfZGVzY3Mo c3ZxLCBlbGVtLT5pbl9zZywgZWxlbS0+aW5fbnVtLCBmYWxzZSwgdHJ1ZSk7Cj4+PiArCj4+PiAr ICAgIC8qCj4+PiArICAgICAqIFB1dCBlbnRyeSBpbiBhdmFpbGFibGUgYXJyYXkgKGJ1dCBkb24n dCB1cGRhdGUgYXZhaWwtPmlkeCB1bnRpbCB0aGV5Cj4+PiArICAgICAqIGRvIHN5bmMpLgo+Pj4g KyAgICAgKi8KPj4+ICsgICAgYXZhaWxfaWR4ID0gc3ZxLT5hdmFpbF9pZHhfc2hhZG93ICYgKHN2 cS0+dnJpbmcubnVtIC0gMSk7Cj4+PiArICAgIGF2YWlsLT5yaW5nW2F2YWlsX2lkeF0gPSBjcHVf dG9fbGUxNihoZWFkKTsKPj4+ICsgICAgc3ZxLT5hdmFpbF9pZHhfc2hhZG93Kys7Cj4+PiArCj4+ PiArICAgIC8qIFVwZGF0ZSBhdmFpbCBpbmRleCBhZnRlciB0aGUgZGVzY3JpcHRvciBpcyB3cm90 ZSAqLwo+Pj4gKyAgICBzbXBfd21iKCk7Cj4+PiArICAgIGF2YWlsLT5pZHggPSBjcHVfdG9fbGUx NihzdnEtPmF2YWlsX2lkeF9zaGFkb3cpOwo+Pj4gKwo+Pj4gKyAgICByZXR1cm4gaGVhZDsKPj4+ ICsKPj4+ICAgIH0KPj4+Cj4+PiAtLyogRm9yd2FyZCBndWVzdCBub3RpZmljYXRpb25zICovCj4+ PiArc3RhdGljIHZvaWQgdmhvc3Rfc3ZxX2FkZChWaG9zdFNoYWRvd1ZpcnRxdWV1ZSAqc3ZxLCBW aXJ0UXVldWVFbGVtZW50ICplbGVtKQo+Pj4gK3sKPj4+ICsgICAgdW5zaWduZWQgcWVtdV9oZWFk ID0gdmhvc3Rfc3ZxX2FkZF9zcGxpdChzdnEsIGVsZW0pOwo+Pj4gKwo+Pj4gKyAgICBzdnEtPnJp bmdfaWRfbWFwc1txZW11X2hlYWRdID0gZWxlbTsKPj4+ICt9Cj4+PiArCj4+PiArLyogSGFuZGxl IGd1ZXN0LT5kZXZpY2Ugbm90aWZpY2F0aW9ucyAqLwo+Pj4gICAgc3RhdGljIHZvaWQgdmhvc3Rf aGFuZGxlX2d1ZXN0X2tpY2soRXZlbnROb3RpZmllciAqbikKPj4+ICAgIHsKPj4+ICAgICAgICBW aG9zdFNoYWRvd1ZpcnRxdWV1ZSAqc3ZxID0gY29udGFpbmVyX29mKG4sIFZob3N0U2hhZG93Vmly dHF1ZXVlLAo+Pj4gQEAgLTYyLDcgKzE4Myw3NCBAQCBzdGF0aWMgdm9pZCB2aG9zdF9oYW5kbGVf Z3Vlc3Rfa2ljayhFdmVudE5vdGlmaWVyICpuKQo+Pj4gICAgICAgICAgICByZXR1cm47Cj4+PiAg ICAgICAgfQo+Pj4KPj4+IC0gICAgZXZlbnRfbm90aWZpZXJfc2V0KCZzdnEtPmtpY2tfbm90aWZp ZXIpOwo+Pj4gKyAgICAvKiBNYWtlIGF2YWlsYWJsZSBhcyBtYW55IGJ1ZmZlcnMgYXMgcG9zc2li bGUgKi8KPj4+ICsgICAgZG8gewo+Pj4gKyAgICAgICAgaWYgKHZpcnRpb19xdWV1ZV9nZXRfbm90 aWZpY2F0aW9uKHN2cS0+dnEpKSB7Cj4+PiArICAgICAgICAgICAgLyogTm8gbW9yZSBub3RpZmlj YXRpb25zIHVudGlsIHByb2Nlc3MgYWxsIGF2YWlsYWJsZSAqLwo+Pj4gKyAgICAgICAgICAgIHZp cnRpb19xdWV1ZV9zZXRfbm90aWZpY2F0aW9uKHN2cS0+dnEsIGZhbHNlKTsKPj4+ICsgICAgICAg IH0KPj4KPj4gVGhpcyBjYW4gYmUgZG9uZSBvdXRzaWRlIHRoZSBsb29wLgo+Pgo+IEkgdGhpbmsg aXQgY2Fubm90LiBUaGUgaW50ZW50aW9uIG9mIGRvaW5nIHRoaXMgd2F5IGlzIHRoYXQgd2UgY2hl Y2sKPiBmb3IgbmV3IGF2YWlsYWJsZSBidWZmZXJzICphbHNvIGFmdGVyKiBlbmFibGluZyBub3Rp ZmljYXRpb25zLCBzbyB3ZQo+IGRvbid0IG1pc3MgYW55IG9mIHRoZW0uIEl0IGlzIG1vcmUgb3Ig bGVzcyBjb3BpZWQgZnJvbQo+IHZpcnRpb19ibGtfaGFuZGxlX3ZxLCB3aGljaCBhbHNvIG5lZWRz IHRvIHJ1biB0byBjb21wbGV0aW9uLgo+Cj4gSWYgd2UgbmVlZCB0byBsb29wIGFnYWluIGJlY2F1 c2UgdGhlcmUgYXJlIG1vcmUgYXZhaWxhYmxlIGJ1ZmZlcnMsIHdlCj4gd2FudCB0byBkaXNhYmxl IG5vdGlmaWNhdGlvbnMgYWdhaW4uIE9yIGFtIEkgbWlzc2luZyBzb21ldGhpbmc/CgoKSSB0aGlu ayB5b3UncmUgcmlnaHQuCgoKPgo+Pj4gKwo+Pj4gKyAgICAgICAgd2hpbGUgKHRydWUpIHsKPj4+ ICsgICAgICAgICAgICBWaXJ0UXVldWVFbGVtZW50ICplbGVtID0gdmlydHF1ZXVlX3BvcChzdnEt PnZxLCBzaXplb2YoKmVsZW0pKTsKPj4+ICsgICAgICAgICAgICBpZiAoIWVsZW0pIHsKPj4+ICsg ICAgICAgICAgICAgICAgYnJlYWs7Cj4+PiArICAgICAgICAgICAgfQo+Pj4gKwo+Pj4gKyAgICAg ICAgICAgIHZob3N0X3N2cV9hZGQoc3ZxLCBlbGVtKTsKPj4+ICsgICAgICAgICAgICBldmVudF9u b3RpZmllcl9zZXQoJnN2cS0+a2lja19ub3RpZmllcik7Cj4+PiArICAgICAgICB9Cj4+PiArCj4+ PiArICAgICAgICB2aXJ0aW9fcXVldWVfc2V0X25vdGlmaWNhdGlvbihzdnEtPnZxLCB0cnVlKTsK Pj4KPj4gSSB0aGluayB0aGlzIGNhbiBiZSBtb3ZlZCB0byB0aGUgZW5kIG9mIHRoaXMgZnVuY3Rp b24uCj4+Cj4gKFNhbWUgYXMgcHJldmlvdXMgYW5zd2VyKQo+Cj4+IEJ0dywgd2UgcHJvYmFibHkg bmVlZCBhIHF1b3RhIHRvIG1ha2Ugc3VyZSB0aGUgc3ZxIGlzIG5vdCBob2dnaW5nIHRoZQo+PiBt YWluIGV2ZW50IGxvb3AuCj4+Cj4+IFNpbWlsYXIgaXNzdWUgY291bGQgYmUgZm91bmQgaW4gYm90 aCB2aXJ0aW8tbmV0IFRYICh1c2luZyB0aW1lciBvciBiaCkKPj4gYW5kIFRBUCAoYSBxdW90YSku Cj4+Cj4gSSB0aGluayB0aGF0IHZpcnRxdWV1ZSBzaXplIGlzIHRoZSBuYXR1cmFsIGxpbWl0IHRv IHRoYXQ6IHNpbmNlIHdlIGFyZQo+IG5vdCBtYWtpbmcgYW55IGJ1ZmZlcnMgdXNlZCBpbiB0aGUg bG9vcCwgdGhlcmUgaXMgbm8gd2F5IHRoYXQgaXQgcnVucwo+IG1vcmUgdGhhbiB2aXJ0cXVldWUg c2l6ZSB0aW1lcy4gSWYgaXQgZG9lcyBiZWNhdXNlIG9mIGFuIGV2aWwvYm9ndXMKPiBndWVzdCwg dmlydHF1ZXVlX3BvcCByYWlzZXMgdGhlIG1lc3NhZ2UgIlZpcnRxdWV1ZSBzaXplIGV4Y2VlZGVk IiBhbmQKPiByZXR1cm5zIE5VTEwsIGVmZmVjdGl2ZWx5IGJyZWFraW5nIHRoZSBsb29wLgo+Cj4g VmlydGlvLW5ldCB0eCBmdW5jdGlvbnMgbWFyayBlYWNoIGJ1ZmZlciByaWdodCBhZnRlciBtYWtp bmcgdGhlbQo+IGF2YWlsYWJsZSBhbmQgdXNlIGl0LCBzbyB0aGV5IGNhbiBob2cgQlFMLiBCdXQg bXkgdW5kZXJzdGFuZGluZyBpcwo+IHRoYXQgaXMgbm90IHBvc3NpYmxlIGluIHRoZSBTVlEgY2Fz ZS4KCgpSaWdodC4KCgo+Cj4gSSBjYW4gYWRkIGEgY29tbWVudCBpbiB0aGUgY29kZSB0byBtYWtl IGl0IGNsZWFyZXIgdGhvdWdoLgoKClllcywgcGxlYXNlLgoKCj4KPj4+ICsgICAgfSB3aGlsZSAo IXZpcnRpb19xdWV1ZV9lbXB0eShzdnEtPnZxKSk7Cj4+PiArfQo+Pj4gKwo+Pj4gK3N0YXRpYyBi b29sIHZob3N0X3N2cV9tb3JlX3VzZWQoVmhvc3RTaGFkb3dWaXJ0cXVldWUgKnN2cSkKPj4+ICt7 Cj4+PiArICAgIGlmIChzdnEtPnVzZWRfaWR4ICE9IHN2cS0+c2hhZG93X3VzZWRfaWR4KSB7Cj4+ PiArICAgICAgICByZXR1cm4gdHJ1ZTsKPj4+ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICAvKiBHZXQg dXNlZCBpZHggbXVzdCBub3QgYmUgcmVvcmRlcmVkICovCj4+PiArICAgIHNtcF9ybWIoKTsKPj4K Pj4gSW50ZXJlc3RpbmcsIHdlIGRvbid0IGRvIHRoaXMgZm9yIGtlcm5lbCBkcml2ZXJzLiBJdCB3 b3VsZCBiZSBoZWxwZnVsIHRvCj4+IGV4cGxhaW4gaXQgbW9yZSBjbGVhciBieSAiWCBtdXN0IGJl IGRvbmUgYmVmb3JlIFkiLgo+Pgo+IEkgdGhpbmsgdGhpcyBnb3QgcmVvcmRlcmVkLCBpdCdzIHN1 cHBvc2VkIHRvIGJlICphZnRlciogZ2V0IHRoZSB1c2VkCj4gaWR4LCBzbyBpdCBtYXRjaGVzIHRo ZSBvbmUgaW4gdGhlIGtlcm5lbCB3aXRoIHRoZSBjb21tZW50ICJPbmx5IGdldAo+IHVzZWQgYXJy YXkgZW50cmllcyBhZnRlciB0aGV5IGhhdmUgYmVlbiBleHBvc2VkIGJ5IGhvc3QuIi4KCgpSaWdo dC4KCgo+Cj4gSSB3aWxsIGNoYW5nZSBpdCBmb3IgdGhlIG5leHQgc2VyaWVzLgoKCk9rLgoKCj4K Pj4+ICsgICAgc3ZxLT5zaGFkb3dfdXNlZF9pZHggPSBjcHVfdG9fbGUxNihzdnEtPnZyaW5nLnVz ZWQtPmlkeCk7Cj4+PiArCj4+PiArICAgIHJldHVybiBzdnEtPnVzZWRfaWR4ICE9IHN2cS0+c2hh ZG93X3VzZWRfaWR4Owo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgVmlydFF1ZXVlRWxlbWVudCAq dmhvc3Rfc3ZxX2dldF9idWYoVmhvc3RTaGFkb3dWaXJ0cXVldWUgKnN2cSkKPj4+ICt7Cj4+PiAr ICAgIHZyaW5nX2Rlc2NfdCAqZGVzY3MgPSBzdnEtPnZyaW5nLmRlc2M7Cj4+PiArICAgIGNvbnN0 IHZyaW5nX3VzZWRfdCAqdXNlZCA9IHN2cS0+dnJpbmcudXNlZDsKPj4+ICsgICAgdnJpbmdfdXNl ZF9lbGVtX3QgdXNlZF9lbGVtOwo+Pj4gKyAgICB1aW50MTZfdCBsYXN0X3VzZWQ7Cj4+PiArCj4+ PiArICAgIGlmICghdmhvc3Rfc3ZxX21vcmVfdXNlZChzdnEpKSB7Cj4+PiArICAgICAgICByZXR1 cm4gTlVMTDsKPj4+ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICBsYXN0X3VzZWQgPSBzdnEtPnVzZWRf aWR4ICYgKHN2cS0+dnJpbmcubnVtIC0gMSk7Cj4+PiArICAgIHVzZWRfZWxlbS5pZCA9IGxlMzJf dG9fY3B1KHVzZWQtPnJpbmdbbGFzdF91c2VkXS5pZCk7Cj4+PiArICAgIHVzZWRfZWxlbS5sZW4g PSBsZTMyX3RvX2NwdSh1c2VkLT5yaW5nW2xhc3RfdXNlZF0ubGVuKTsKPj4+ICsKPj4+ICsgICAg c3ZxLT51c2VkX2lkeCsrOwo+Pj4gKyAgICBpZiAodW5saWtlbHkodXNlZF9lbGVtLmlkID49IHN2 cS0+dnJpbmcubnVtKSkgewo+Pj4gKyAgICAgICAgZXJyb3JfcmVwb3J0KCJEZXZpY2UgJXMgc2F5 cyBpbmRleCAldSBpcyB1c2VkIiwgc3ZxLT52ZGV2LT5uYW1lLAo+Pj4gKyAgICAgICAgICAgICAg ICAgICAgIHVzZWRfZWxlbS5pZCk7Cj4+PiArICAgICAgICByZXR1cm4gTlVMTDsKPj4+ICsgICAg fQo+Pj4gKwo+Pj4gKyAgICBpZiAodW5saWtlbHkoIXN2cS0+cmluZ19pZF9tYXBzW3VzZWRfZWxl bS5pZF0pKSB7Cj4+PiArICAgICAgICBlcnJvcl9yZXBvcnQoCj4+PiArICAgICAgICAgICAgIkRl dmljZSAlcyBzYXlzIGluZGV4ICV1IGlzIHVzZWQsIGJ1dCBpdCB3YXMgbm90IGF2YWlsYWJsZSIs Cj4+PiArICAgICAgICAgICAgc3ZxLT52ZGV2LT5uYW1lLCB1c2VkX2VsZW0uaWQpOwo+Pj4gKyAg ICAgICAgcmV0dXJuIE5VTEw7Cj4+PiArICAgIH0KPj4+ICsKPj4+ICsgICAgZGVzY3NbdXNlZF9l bGVtLmlkXS5uZXh0ID0gc3ZxLT5mcmVlX2hlYWQ7Cj4+PiArICAgIHN2cS0+ZnJlZV9oZWFkID0g dXNlZF9lbGVtLmlkOwo+Pj4gKwo+Pj4gKyAgICBzdnEtPnJpbmdfaWRfbWFwc1t1c2VkX2VsZW0u aWRdLT5sZW4gPSB1c2VkX2VsZW0ubGVuOwo+Pj4gKyAgICByZXR1cm4gZ19zdGVhbF9wb2ludGVy KCZzdnEtPnJpbmdfaWRfbWFwc1t1c2VkX2VsZW0uaWRdKTsKPj4+ICAgIH0KPj4+Cj4+PiAgICAv KiBGb3J3YXJkIHZob3N0IG5vdGlmaWNhdGlvbnMgKi8KPj4+IEBAIC03MCw4ICsyNTgsMjYgQEAg c3RhdGljIHZvaWQgdmhvc3Rfc3ZxX2hhbmRsZV9jYWxsX25vX3Rlc3QoRXZlbnROb3RpZmllciAq bikKPj4+ICAgIHsKPj4+ICAgICAgICBWaG9zdFNoYWRvd1ZpcnRxdWV1ZSAqc3ZxID0gY29udGFp bmVyX29mKG4sIFZob3N0U2hhZG93VmlydHF1ZXVlLAo+Pj4gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY2FsbF9ub3RpZmllcik7Cj4+PiAtCj4+PiAtICAg IGV2ZW50X25vdGlmaWVyX3NldCgmc3ZxLT5ndWVzdF9jYWxsX25vdGlmaWVyKTsKPj4+ICsgICAg VmlydFF1ZXVlICp2cSA9IHN2cS0+dnE7Cj4+PiArCj4+PiArICAgIC8qIE1ha2UgYXMgbWFueSBi dWZmZXJzIGFzIHBvc3NpYmxlIHVzZWQuICovCj4+PiArICAgIGRvIHsKPj4+ICsgICAgICAgIHVu c2lnbmVkIGkgPSAwOwo+Pj4gKwo+Pj4gKyAgICAgICAgLyogVE9ETzogVXNlIFZSSU5HX0FWQUlM X0ZfTk9fSU5URVJSVVBUICovCj4+PiArICAgICAgICB3aGlsZSAodHJ1ZSkgewo+Pj4gKyAgICAg ICAgICAgIGdfYXV0b2ZyZWUgVmlydFF1ZXVlRWxlbWVudCAqZWxlbSA9IHZob3N0X3N2cV9nZXRf YnVmKHN2cSk7Cj4+PiArICAgICAgICAgICAgaWYgKCFlbGVtKSB7Cj4+PiArICAgICAgICAgICAg ICAgIGJyZWFrOwo+Pj4gKyAgICAgICAgICAgIH0KPj4+ICsKPj4+ICsgICAgICAgICAgICBhc3Nl cnQoaSA8IHN2cS0+dnJpbmcubnVtKTsKPj4KPj4gTGV0J3MgcmV0dXJuIGVycm9yIGluc3RlYWQg b2YgdXNpbmcgdGhlIGFzc2VydC4KPj4KPiBBY3R1YWxseSB0aGlzIGlzIGEgY29uZGl0aW9uIHRo YXQgd2Ugc2hvdWxkIG5ldmVyIG1lZXQ6IEluIHRoZSBjYXNlIG9mCj4gcmluZyBvdmVycnVuLCBk ZXZpY2Ugd291bGQgdHJ5IHRvIHNldCB1c2VkIGEgZGVzY3JpcHRvciB0aGF0IGlzIGVpdGhlcgo+ PiB2cmluZyBzaXplICpvciogc2hvdWxkIHRyeSB0byBvdmVycnVuIHNvbWUgb2YgdGhlIGFscmVh ZHkgdXNlZCBvbmVzLgo+IEluIGJvdGggY2FzZXMsIGVsZW0gc2hvdWxkIGJlIE5VTEwgYW5kIHRo ZSBsb29wIHNob3VsZCBicmVhay4KPgo+IFNvIHRoaXMgaXMgYSBzYWZldHkgbmV0IHByb3RlY3Rp bmcgZnJvbSBib3RoLCBpZiB3ZSBoYXZlIGFuIGkgPgo+IHN2cS0+dnJpbmcubnVtIG1lYW5zIHdl IGFyZSBub3QgcHJvY2Vzc2luZyB1c2VkIGJ1ZmZlcnMgd2VsbCBhbnltb3JlLAo+IGFuZCAobW9y ZW92ZXIpIHRoaXMgaXMgaGFwcGVuaW5nIGFmdGVyIG1ha2luZyB1c2VkIGFsbCBkZXNjcmlwdG9y cy4KPgo+IFRha2luZyB0aGF0IGludG8gYWNjb3VudCwgc2hvdWxkIHdlIGRlbGV0ZSBpdD8KCgpN YXliZSBhIHdhcm5pbmcgaW5zdGVhZC4KCgo+Cj4+PiArICAgICAgICAgICAgdmlydHF1ZXVlX2Zp bGwodnEsIGVsZW0sIGVsZW0tPmxlbiwgaSsrKTsKPj4+ICsgICAgICAgIH0KPj4+ICsKPj4+ICsg ICAgICAgIHZpcnRxdWV1ZV9mbHVzaCh2cSwgaSk7Cj4+PiArICAgICAgICBldmVudF9ub3RpZmll cl9zZXQoJnN2cS0+Z3Vlc3RfY2FsbF9ub3RpZmllcik7Cj4+PiArICAgIH0gd2hpbGUgKHZob3N0 X3N2cV9tb3JlX3VzZWQoc3ZxKSk7Cj4+PiAgICB9Cj4+Pgo+Pj4gICAgc3RhdGljIHZvaWQgdmhv c3Rfc3ZxX2hhbmRsZV9jYWxsKEV2ZW50Tm90aWZpZXIgKm4pCj4+PiBAQCAtMjA0LDEyICs0MTAs MjUgQEAgZXJyX3NldF92cmluZ19raWNrOgo+Pj4gICAgdm9pZCB2aG9zdF9zdnFfc3RvcChzdHJ1 Y3Qgdmhvc3RfZGV2ICpkZXYsIHVuc2lnbmVkIGlkeCwKPj4+ICAgICAgICAgICAgICAgICAgICAg ICAgVmhvc3RTaGFkb3dWaXJ0cXVldWUgKnN2cSkKPj4+ICAgIHsKPj4+ICsgICAgaW50IGk7Cj4+ PiAgICAgICAgaW50IHIgPSB2aG9zdF9zdnFfcmVzdG9yZV92ZGV2X2hvc3Rfbm90aWZpZXIoZGV2 LCBpZHgsIHN2cSk7Cj4+PiArCj4+PiAgICAgICAgaWYgKHVubGlrZWx5KHIgPCAwKSkgewo+Pj4g ICAgICAgICAgICBlcnJvcl9yZXBvcnQoIkNvdWxkbid0IHJlc3RvcmUgdnEga2ljayBmZDogJXMi LCBzdHJlcnJvcigtcikpOwo+Pj4gICAgICAgIH0KPj4+Cj4+PiAgICAgICAgZXZlbnRfbm90aWZp ZXJfc2V0X2hhbmRsZXIoJnN2cS0+aG9zdF9ub3RpZmllciwgTlVMTCk7Cj4+PiArCj4+PiArICAg IGZvciAoaSA9IDA7IGkgPCBzdnEtPnZyaW5nLm51bTsgKytpKSB7Cj4+PiArICAgICAgICBnX2F1 dG9mcmVlIFZpcnRRdWV1ZUVsZW1lbnQgKmVsZW0gPSBzdnEtPnJpbmdfaWRfbWFwc1tpXTsKPj4+ ICsgICAgICAgIC8qCj4+PiArICAgICAgICAgKiBBbHRob3VnaCB0aGUgZG9jIHNheXMgd2UgbXVz dCB1bnBvcCBpbiBvcmRlciwgaXQncyBvayB0byB1bnBvcAo+Pj4gKyAgICAgICAgICogZXZlcnl0 aGluZy4KPj4+ICsgICAgICAgICAqLwo+Pj4gKyAgICAgICAgaWYgKGVsZW0pIHsKPj4+ICsgICAg ICAgICAgICB2aXJ0cXVldWVfdW5wb3Aoc3ZxLT52cSwgZWxlbSwgZWxlbS0+bGVuKTsKPj4+ICsg ICAgICAgIH0KPj4KPj4gV2lsbCB0aGlzIHJlc3VsdCBzb21lIG9mIHRoZSAicGVuZGluZyIgYnVm ZmVycyB0byBiZSBzdWJtaXR0ZWQgbXVsdGlwbGUKPj4gdGltZXM/IElmIHllcywgc2hvdWxkIHdl IHdhaXQgZm9yIGFsbCB0aGUgYnVmZmVycyB1c2VkIGluc3RlYWQgb2YgZG9pbmcKPj4gdGhlIHVu cG9wIGhlcmU/Cj4+Cj4gRG8geW91IG1lYW4gdG8gY2FsbCB2aXJ0cXVldWVfdW5wb3Agd2l0aCB0 aGUgc2FtZSBlbGVtIChvciBlbGVtLmlkKQo+IG11bHRpcGxlIHRpbWVzPyBUaGF0IHNob3VsZCBu ZXZlciBoYXBwZW4sIGJlY2F1c2UgZWxlbS5pZCBzaG91bGQgYmUKPiB0aGUgcG9zaXRpb24gaW4g dGhlIHJpbmdfaWRfbWFwcy4gQWxzbywgdW5wb3AoKSBzaG91bGQganVzdCB1bm1hcCB0aGUKPiBl bGVtZW50IGFuZCBuZXZlciBzeW5jIGFnYWluLgo+Cj4gTWF5YmUgaXQgaXMgd2F5IGNsZWFyZXIg dG8gY2FsbCB2aXJ0cXVldWVfZGV0YWNoX2VsZW1lbnQgaGVyZSBkaXJlY3RseS4KCgpJIG1lYW50 IGJhc2ljYWxseSBmb3IgdGhlIGJ1ZmZlcnMgdGhhdCB3ZXJlIGNvbnN1bWVkIGJ5IHRoZSBkZXZp Y2UgYnV0IApub3QgbWFkZSB1c2VkLiBJbiB0aGlzIGNhc2UgaWYgd2UgdW5wb3AgaGVyZS4gSXQg d2lsbCBiZSBwcm9jZXNzZWQgYnkgCnRoZSBkZXZpY2UgbGF0ZXIgdmlhIHZob3N0LXZkcGEgYWdh aW4/CgpUaGlzIGlzIHByb2JhYmx5IGZpbmUgZm9yIG5ldCBidXQgSSdtIG5vdCBzdXJlIGl0IHdv cmtzIGZvciBvdGhlciAKZGV2aWNlcy4gQW5vdGhlciB3YXkgaXMgdG8gd2FpdCB1bnRpbCBhbGwg dGhlIGNvbnN1bWVkIGJ1ZmZlciB1c2VkLgoKCj4KPj4+ICsgICAgfQo+Pj4gICAgfQo+Pj4KPj4+ ICAgIC8qCj4+PiBAQCAtMjI0LDcgKzQ0Myw3IEBAIFZob3N0U2hhZG93VmlydHF1ZXVlICp2aG9z dF9zdnFfbmV3KHN0cnVjdCB2aG9zdF9kZXYgKmRldiwgaW50IGlkeCkKPj4+ICAgICAgICBzaXpl X3QgZHJpdmVyX3NpemU7Cj4+PiAgICAgICAgc2l6ZV90IGRldmljZV9zaXplOwo+Pj4gICAgICAg IGdfYXV0b2ZyZWUgVmhvc3RTaGFkb3dWaXJ0cXVldWUgKnN2cSA9IGdfbmV3MChWaG9zdFNoYWRv d1ZpcnRxdWV1ZSwgMSk7Cj4+PiAtICAgIGludCByOwo+Pj4gKyAgICBpbnQgciwgaTsKPj4+Cj4+ PiAgICAgICAgciA9IGV2ZW50X25vdGlmaWVyX2luaXQoJnN2cS0+a2lja19ub3RpZmllciwgMCk7 Cj4+PiAgICAgICAgaWYgKHIgIT0gMCkgewo+Pj4gQEAgLTI1MCw2ICs0NjksMTEgQEAgVmhvc3RT aGFkb3dWaXJ0cXVldWUgKnZob3N0X3N2cV9uZXcoc3RydWN0IHZob3N0X2RldiAqZGV2LCBpbnQg aWR4KQo+Pj4gICAgICAgIG1lbXNldChzdnEtPnZyaW5nLmRlc2MsIDAsIGRyaXZlcl9zaXplKTsK Pj4+ICAgICAgICBzdnEtPnZyaW5nLnVzZWQgPSBxZW11X21lbWFsaWduKHFlbXVfcmVhbF9ob3N0 X3BhZ2Vfc2l6ZSwgZGV2aWNlX3NpemUpOwo+Pj4gICAgICAgIG1lbXNldChzdnEtPnZyaW5nLnVz ZWQsIDAsIGRldmljZV9zaXplKTsKPj4+ICsgICAgZm9yIChpID0gMDsgaSA8IG51bSAtIDE7IGkr Kykgewo+Pj4gKyAgICAgICAgc3ZxLT52cmluZy5kZXNjW2ldLm5leHQgPSBjcHVfdG9fbGUxNihp ICsgMSk7Cj4+PiArICAgIH0KPj4+ICsKPj4+ICsgICAgc3ZxLT5yaW5nX2lkX21hcHMgPSBnX25l dzAoVmlydFF1ZXVlRWxlbWVudCAqLCBudW0pOwo+Pj4gICAgICAgIGV2ZW50X25vdGlmaWVyX3Nl dF9oYW5kbGVyKCZzdnEtPmNhbGxfbm90aWZpZXIsCj4+PiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdmhvc3Rfc3ZxX2hhbmRsZV9jYWxsKTsKPj4+ICAgICAgICByZXR1cm4gZ19z dGVhbF9wb2ludGVyKCZzdnEpOwo+Pj4gQEAgLTI2OSw2ICs0OTMsNyBAQCB2b2lkIHZob3N0X3N2 cV9mcmVlKFZob3N0U2hhZG93VmlydHF1ZXVlICp2cSkKPj4+ICAgICAgICBldmVudF9ub3RpZmll cl9jbGVhbnVwKCZ2cS0+a2lja19ub3RpZmllcik7Cj4+PiAgICAgICAgZXZlbnRfbm90aWZpZXJf c2V0X2hhbmRsZXIoJnZxLT5jYWxsX25vdGlmaWVyLCBOVUxMKTsKPj4+ICAgICAgICBldmVudF9u b3RpZmllcl9jbGVhbnVwKCZ2cS0+Y2FsbF9ub3RpZmllcik7Cj4+PiArICAgIGdfZnJlZSh2cS0+ cmluZ19pZF9tYXBzKTsKPj4+ICAgICAgICBxZW11X3ZmcmVlKHZxLT52cmluZy5kZXNjKTsKPj4+ ICAgICAgICBxZW11X3ZmcmVlKHZxLT52cmluZy51c2VkKTsKPj4+ICAgICAgICBnX2ZyZWUodnEp Owo+Pj4gZGlmZiAtLWdpdCBhL2h3L3ZpcnRpby92aG9zdC12ZHBhLmMgYi9ody92aXJ0aW8vdmhv c3QtdmRwYS5jCj4+PiBpbmRleCBhMDU3ZTgyNzdkLi5iYjcwMTBkZGI1IDEwMDY0NAo+Pj4gLS0t IGEvaHcvdmlydGlvL3Zob3N0LXZkcGEuYwo+Pj4gKysrIGIvaHcvdmlydGlvL3Zob3N0LXZkcGEu Ywo+Pj4gQEAgLTE5LDYgKzE5LDcgQEAKPj4+ICAgICNpbmNsdWRlICJody92aXJ0aW8vdmlydGlv LW5ldC5oIgo+Pj4gICAgI2luY2x1ZGUgImh3L3ZpcnRpby92aG9zdC1zaGFkb3ctdmlydHF1ZXVl LmgiCj4+PiAgICAjaW5jbHVkZSAiaHcvdmlydGlvL3Zob3N0LXZkcGEuaCIKPj4+ICsjaW5jbHVk ZSAiaHcvdmlydGlvL3Zob3N0LXNoYWRvdy12aXJ0cXVldWUuaCIKPj4+ICAgICNpbmNsdWRlICJl eGVjL2FkZHJlc3Mtc3BhY2VzLmgiCj4+PiAgICAjaW5jbHVkZSAicWVtdS9tYWluLWxvb3AuaCIK Pj4+ICAgICNpbmNsdWRlICJjcHUuaCIKPj4+IEBAIC00NzUsNiArNDc2LDI4IEBAIHN0YXRpYyBp bnQgdmhvc3RfdmRwYV9zZXRfZmVhdHVyZXMoc3RydWN0IHZob3N0X2RldiAqZGV2LAo+Pj4gICAg ICAgIHJldHVybiB2aG9zdF92ZHBhX2JhY2tlbmRfc2V0X2ZlYXR1cmVzKGRldiwgZmVhdHVyZXMp Owo+Pj4gICAgfQo+Pj4KPj4+ICsvKioKPj4+ICsgKiBSZXN0b3JlIGd1ZXN0IGZlYXR1cmVzIHRv IHZkcGEgZGV2aWNlCj4+PiArICovCj4+PiArc3RhdGljIGludCB2aG9zdF92ZHBhX3NldF9ndWVz dF9mZWF0dXJlcyhzdHJ1Y3Qgdmhvc3RfZGV2ICpkZXYpCj4+PiArewo+Pj4gKyAgICBzdHJ1Y3Qg dmhvc3RfdmRwYSAqdiA9IGRldi0+b3BhcXVlOwo+Pj4gKyAgICByZXR1cm4gdmhvc3RfdmRwYV9i YWNrZW5kX3NldF9mZWF0dXJlcyhkZXYsIHYtPmd1ZXN0X2ZlYXR1cmVzKTsKPj4+ICt9Cj4+PiAr Cj4+PiArLyoqCj4+PiArICogU2V0IHNoYWRvdyB2aXJ0cXVldWUgc3VwcG9ydGVkIGZlYXR1cmVz Cj4+PiArICovCj4+PiArc3RhdGljIGludCB2aG9zdF92ZHBhX3NldF9zdnFfZmVhdHVyZXMoc3Ry dWN0IHZob3N0X2RldiAqZGV2KQo+Pj4gK3sKPj4+ICsgICAgc3RydWN0IHZob3N0X3ZkcGEgKnYg PSBkZXYtPm9wYXF1ZTsKPj4+ICsgICAgdWludDY0X3QgZmVhdHVyZXMgPSB2LT5ob3N0X2ZlYXR1 cmVzOwo+Pj4gKyAgICBib29sIGIgPSB2aG9zdF9zdnFfdmFsaWRfZGV2aWNlX2ZlYXR1cmVzKCZm ZWF0dXJlcyk7Cj4+PiArICAgIGFzc2VydChiKTsKPj4+ICsKPj4+ICsgICAgcmV0dXJuIHZob3N0 X3ZkcGFfYmFja2VuZF9zZXRfZmVhdHVyZXMoZGV2LCBmZWF0dXJlcyk7Cj4+PiArfQo+Pj4gKwo+ Pj4gICAgc3RhdGljIGludCB2aG9zdF92ZHBhX3NldF9iYWNrZW5kX2NhcChzdHJ1Y3Qgdmhvc3Rf ZGV2ICpkZXYpCj4+PiAgICB7Cj4+PiAgICAgICAgdWludDY0X3QgZmVhdHVyZXM7Cj4+PiBAQCAt NzMwLDYgKzc1MywxOSBAQCBzdGF0aWMgYm9vbCAgdmhvc3RfdmRwYV9mb3JjZV9pb21tdShzdHJ1 Y3Qgdmhvc3RfZGV2ICpkZXYpCj4+PiAgICAgICAgcmV0dXJuIHRydWU7Cj4+PiAgICB9Cj4+Pgo+ Pj4gK3N0YXRpYyBpbnQgdmhvc3RfdmRwYV92cmluZ19wYXVzZShzdHJ1Y3Qgdmhvc3RfZGV2ICpk ZXYpCj4+PiArewo+Pj4gKyAgICBpbnQgcjsKPj4+ICsgICAgdWludDhfdCBzdGF0dXM7Cj4+PiAr Cj4+PiArICAgIHZob3N0X3ZkcGFfYWRkX3N0YXR1cyhkZXYsIFZJUlRJT19DT05GSUdfU19ERVZJ Q0VfU1RPUFBFRCk7Cj4+PiArICAgIGRvIHsKPj4+ICsgICAgICAgIHIgPSB2aG9zdF92ZHBhX2Nh bGwoZGV2LCBWSE9TVF9WRFBBX0dFVF9TVEFUVVMsICZzdGF0dXMpOwo+Pgo+PiBJIGd1ZXNzIHdl J2QgYmV0dGVyIGFkZCBzb21lIHNsZWVwIGhlcmUuCj4+Cj4gSWYgdGhlIGZpbmFsIHZlcnNpb24g c3RpbGwgY29udGFpbnMgdGhlIGNhbGwsIEkgd2lsbCBhZGQgdGhlIHNsZWVwLiBBdAo+IHRoZSBt b21lbnQgSSB0aGluayBpdCdzIGJldHRlciBpZiB3ZSBzdG9wIHRoZSBkZXZpY2UgYnkgYSB2ZHBh IGlvY3RsLgoKCk9rLCBzbyB0aGUgaWRlYSBpcyB0byBzbGVlcCBpbiB0aGUgaW9jdGw/CgoKPgo+ Pj4gKyAgICB9IHdoaWxlIChyID09IDAgJiYgIShzdGF0dXMgJiBWSVJUSU9fQ09ORklHX1NfREVW SUNFX1NUT1BQRUQpKTsKPj4+ICsKPj4+ICsgICAgcmV0dXJuIDA7Cj4+PiArfQo+Pj4gKwo+Pj4g ICAgLyoKPj4+ICAgICAqIFN0YXJ0IHNoYWRvdyB2aXJ0cXVldWUuCj4+PiAgICAgKi8KPj4+IEBA IC03NDIsOSArNzc4LDI5IEBAIHN0YXRpYyBib29sIHZob3N0X3ZkcGFfc3ZxX3N0YXJ0X3ZxKHN0 cnVjdCB2aG9zdF9kZXYgKmRldiwgdW5zaWduZWQgaWR4KQo+Pj4gICAgICAgICAgICAuaW5kZXgg PSBpZHggKyBkZXYtPnZxX2luZGV4LAo+Pj4gICAgICAgICAgICAuZmQgPSBldmVudF9ub3RpZmll cl9nZXRfZmQodmhvc3RfY2FsbF9ub3RpZmllciksCj4+PiAgICAgICAgfTsKPj4+ICsgICAgc3Ry dWN0IHZob3N0X3ZyaW5nX2FkZHIgYWRkciA9IHsKPj4+ICsgICAgICAgIC5pbmRleCA9IGlkeCAr IGRldi0+dnFfaW5kZXgsCj4+PiArICAgIH07Cj4+PiArICAgIHN0cnVjdCB2aG9zdF92cmluZ19z dGF0ZSBudW0gPSB7Cj4+PiArICAgICAgICAuaW5kZXggPSBpZHggKyBkZXYtPnZxX2luZGV4LAo+ Pj4gKyAgICAgICAgLm51bSA9IHZpcnRpb19xdWV1ZV9nZXRfbnVtKGRldi0+dmRldiwgaWR4KSwK Pj4+ICsgICAgfTsKPj4+ICAgICAgICBpbnQgcjsKPj4+ICAgICAgICBib29sIGI7Cj4+Pgo+Pj4g KyAgICB2aG9zdF9zdnFfZ2V0X3ZyaW5nX2FkZHIoc3ZxLCAmYWRkcik7Cj4+PiArICAgIHIgPSB2 aG9zdF92ZHBhX3NldF92cmluZ19hZGRyKGRldiwgJmFkZHIpOwo+Pj4gKyAgICBpZiAodW5saWtl bHkocikpIHsKPj4+ICsgICAgICAgIGVycm9yX3JlcG9ydCgidmhvc3Rfc2V0X3ZyaW5nX2FkZHIg Zm9yIHNoYWRvdyB2cSBmYWlsZWQiKTsKPj4+ICsgICAgICAgIHJldHVybiBmYWxzZTsKPj4+ICsg ICAgfQo+Pj4gKwo+Pj4gKyAgICByID0gdmhvc3RfdmRwYV9zZXRfdnJpbmdfbnVtKGRldiwgJm51 bSk7Cj4+PiArICAgIGlmICh1bmxpa2VseShyKSkgewo+Pj4gKyAgICAgICAgZXJyb3JfcmVwb3J0 KCJ2aG9zdF92ZHBhX3NldF92cmluZ19udW0gZm9yIHNoYWRvdyB2cSBmYWlsZWQiKTsKPj4+ICsg ICAgICAgIHJldHVybiBmYWxzZTsKPj4+ICsgICAgfQo+Pj4gKwo+Pj4gICAgICAgIC8qIFNldCBz aGFkb3cgdnEgLT4gZ3Vlc3Qgbm90aWZpZXIgKi8KPj4+ICAgICAgICBhc3NlcnQodi0+Y2FsbF9m ZFtpZHhdKTsKPj4+ICAgICAgICB2aG9zdF9zdnFfc2V0X2d1ZXN0X2NhbGxfbm90aWZpZXIoc3Zx LCB2LT5jYWxsX2ZkW2lkeF0pOwo+Pj4gQEAgLTc4MSwxNSArODM3LDMyIEBAIHN0YXRpYyB1bnNp Z25lZCB2aG9zdF92ZHBhX2VuYWJsZV9zdnEoc3RydWN0IHZob3N0X3ZkcGEgKnYsIGJvb2wgZW5h YmxlKQo+Pj4gICAgICAgICAgICBhc3NlcnQodi0+c2hhZG93X3Zxcy0+bGVuID09IDApOwo+Pj4g ICAgICAgICAgICBmb3IgKG4gPSAwOyBuIDwgaGRldi0+bnZxczsgKytuKSB7Cj4+PiAgICAgICAg ICAgICAgICBWaG9zdFNoYWRvd1ZpcnRxdWV1ZSAqc3ZxID0gdmhvc3Rfc3ZxX25ldyhoZGV2LCBu KTsKPj4+IC0gICAgICAgICAgICBib29sIG9rOwo+Pj4gLQo+Pj4gICAgICAgICAgICAgICAgaWYg KHVubGlrZWx5KCFzdnEpKSB7Cj4+PiAgICAgICAgICAgICAgICAgICAgZ19wdHJfYXJyYXlfc2V0 X3NpemUodi0+c2hhZG93X3ZxcywgMCk7Cj4+PiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIDA7 Cj4+PiAgICAgICAgICAgICAgICB9Cj4+PiAgICAgICAgICAgICAgICBnX3B0cl9hcnJheV9hZGQo di0+c2hhZG93X3Zxcywgc3ZxKTsKPj4+ICsgICAgICAgIH0KPj4+ICsgICAgfQo+Pj4KPj4+IC0g ICAgICAgICAgICBvayA9IHZob3N0X3ZkcGFfc3ZxX3N0YXJ0X3ZxKGhkZXYsIG4pOwo+Pj4gKyAg ICByID0gdmhvc3RfdmRwYV92cmluZ19wYXVzZShoZGV2KTsKPj4+ICsgICAgYXNzZXJ0KHIgPT0g MCk7Cj4+PiArCj4+PiArICAgIGlmIChlbmFibGUpIHsKPj4+ICsgICAgICAgIGZvciAobiA9IDA7 IG4gPCB2LT5zaGFkb3dfdnFzLT5sZW47ICsrbikgewo+Pj4gKyAgICAgICAgICAgIC8qIE9idGFp biBWaXJ0cXVldWUgc3RhdGUgKi8KPj4+ICsgICAgICAgICAgICB2aG9zdF92aXJ0cXVldWVfc3Rv cChoZGV2LCBoZGV2LT52ZGV2LCAmaGRldi0+dnFzW25dLCBuKTsKPj4+ICsgICAgICAgIH0KPj4+ ICsgICAgfQo+Pj4gKwo+Pj4gKyAgICAvKiBSZXNldCBkZXZpY2Ugc28gaXQgY2FuIGJlIGNvbmZp Z3VyZWQgKi8KPj4+ICsgICAgciA9IHZob3N0X3ZkcGFfZGV2X3N0YXJ0KGhkZXYsIGZhbHNlKTsK Pj4+ICsgICAgYXNzZXJ0KHIgPT0gMCk7Cj4+PiArCj4+PiArICAgIGlmIChlbmFibGUpIHsKPj4+ ICsgICAgICAgIGludCByOwo+Pj4gKyAgICAgICAgZm9yIChuID0gMDsgbiA8IHYtPnNoYWRvd192 cXMtPmxlbjsgKytuKSB7Cj4+PiArICAgICAgICAgICAgYm9vbCBvayA9IHZob3N0X3ZkcGFfc3Zx X3N0YXJ0X3ZxKGhkZXYsIG4pOwo+Pj4gICAgICAgICAgICAgICAgaWYgKHVubGlrZWx5KCFvaykp IHsKPj4+ICAgICAgICAgICAgICAgICAgICAvKiBGcmVlIHN0aWxsIG5vdCBzdGFydGVkIHN2cXMg Ki8KPj4+ICAgICAgICAgICAgICAgICAgICBnX3B0cl9hcnJheV9zZXRfc2l6ZSh2LT5zaGFkb3df dnFzLCBuKTsKPj4+IEBAIC03OTcsMTEgKzg3MCwxOSBAQCBzdGF0aWMgdW5zaWduZWQgdmhvc3Rf dmRwYV9lbmFibGVfc3ZxKHN0cnVjdCB2aG9zdF92ZHBhICp2LCBib29sIGVuYWJsZSkKPj4+ICAg ICAgICAgICAgICAgICAgICBicmVhazsKPj4+ICAgICAgICAgICAgICAgIH0KPj4+ICAgICAgICAg ICAgfQo+Pj4gKwo+Pj4gKyAgICAgICAgLyogTmVlZCB0byBhY2sgZmVhdHVyZXMgdG8gc2V0IHN0 YXRlIGluIHZwX3ZkcGEgZGV2aWNlcyAqLwo+Pgo+PiB2aG9zdF92ZHBhIGFjdHVhbGx5Pwo+Pgo+ IFllcywgd2hhdCBhIG1pc3Rha2UhCj4KPj4+ICsgICAgICAgIHIgPSB2aG9zdF92ZHBhX3NldF9z dnFfZmVhdHVyZXMoaGRldik7Cj4+PiArICAgICAgICBpZiAodW5saWtlbHkocikpIHsKPj4+ICsg ICAgICAgICAgICBlbmFibGUgPSBmYWxzZTsKPj4+ICsgICAgICAgIH0KPj4+ICAgICAgICB9Cj4+ Pgo+Pj4gICAgICAgIHYtPnNoYWRvd192cXNfZW5hYmxlZCA9IGVuYWJsZTsKPj4+Cj4+PiAgICAg ICAgaWYgKCFlbmFibGUpIHsKPj4+ICsgICAgICAgIHZob3N0X3ZkcGFfc2V0X2d1ZXN0X2ZlYXR1 cmVzKGhkZXYpOwo+Pj4gKwo+Pj4gICAgICAgICAgICAvKiBEaXNhYmxlIGFsbCBxdWV1ZXMgb3Ig Y2xlYW4gdXAgZmFpbGVkIHN0YXJ0ICovCj4+PiAgICAgICAgICAgIGZvciAobiA9IDA7IG4gPCB2 LT5zaGFkb3dfdnFzLT5sZW47ICsrbikgewo+Pj4gICAgICAgICAgICAgICAgc3RydWN0IHZob3N0 X3ZyaW5nX2ZpbGUgZmlsZSA9IHsKPj4+IEBAIC04MTgsNyArODk5LDEyIEBAIHN0YXRpYyB1bnNp Z25lZCB2aG9zdF92ZHBhX2VuYWJsZV9zdnEoc3RydWN0IHZob3N0X3ZkcGEgKnYsIGJvb2wgZW5h YmxlKQo+Pj4gICAgICAgICAgICAgICAgLyogVE9ETzogVGhpcyBjYW4gdW5tYXNrIG9yIG92ZXJy aWRlIGNhbGwgZmQhICovCj4+PiAgICAgICAgICAgICAgICB2aG9zdF92aXJ0cXVldWVfc3RhcnQo aGRldiwgaGRldi0+dmRldiwgJmhkZXYtPnZxc1tuXSwgdnFfaWR4KTsKPj4+ICAgICAgICAgICAg fQo+Pj4gKyAgICB9Cj4+Pgo+Pj4gKyAgICByID0gdmhvc3RfdmRwYV9kZXZfc3RhcnQoaGRldiwg dHJ1ZSk7Cj4+PiArICAgIGFzc2VydChyID09IDApOwo+Pj4gKwo+Pj4gKyAgICBpZiAoIWVuYWJs ZSkgewo+Pj4gICAgICAgICAgICAvKiBSZXNvdXJjZXMgY2xlYW51cCAqLwo+Pj4gICAgICAgICAg ICBnX3B0cl9hcnJheV9zZXRfc2l6ZSh2LT5zaGFkb3dfdnFzLCAwKTsKPj4+ICAgICAgICB9Cj4+ PiBAQCAtODMxLDYgKzkxNyw3IEBAIHZvaWQgcW1wX3hfdmhvc3RfZW5hYmxlX3NoYWRvd192cShj b25zdCBjaGFyICpuYW1lLCBib29sIGVuYWJsZSwgRXJyb3IgKiplcnJwKQo+Pj4gICAgICAgIHN0 cnVjdCB2aG9zdF92ZHBhICp2Owo+Pj4gICAgICAgIGNvbnN0IGNoYXIgKmVycl9jYXVzZSA9IE5V TEw7Cj4+PiAgICAgICAgYm9vbCByOwo+Pj4gKyAgICB1aW50NjRfdCBzdnFfZmVhdHVyZXM7Cj4+ Pgo+Pj4gICAgICAgIFFMSVNUX0ZPUkVBQ0godiwgJnZob3N0X3ZkcGFfZGV2aWNlcywgZW50cnkp IHsKPj4+ICAgICAgICAgICAgaWYgKHYtPmRldi0+dmRldiAmJiAwID09IHN0cmNtcCh2LT5kZXYt PnZkZXYtPm5hbWUsIG5hbWUpKSB7Cj4+PiBAQCAtODQ2LDYgKzkzMywyMCBAQCB2b2lkIHFtcF94 X3Zob3N0X2VuYWJsZV9zaGFkb3dfdnEoY29uc3QgY2hhciAqbmFtZSwgYm9vbCBlbmFibGUsIEVy cm9yICoqZXJycCkKPj4+ICAgICAgICAgICAgZ290byBlcnI7Cj4+PiAgICAgICAgfQo+Pj4KPj4+ ICsgICAgc3ZxX2ZlYXR1cmVzID0gdi0+aG9zdF9mZWF0dXJlczsKPj4+ICsgICAgaWYgKCF2aG9z dF9zdnFfdmFsaWRfZGV2aWNlX2ZlYXR1cmVzKCZzdnFfZmVhdHVyZXMpKSB7Cj4+PiArICAgICAg ICBlcnJvcl9zZXRnKGVycnAsCj4+PiArICAgICAgICAgICAgIkNhbid0IGVuYWJsZSBzaGFkb3cg dnEgb24gJXM6IFVuZXhwZWN0ZWQgZmVhdHVyZSBmbGFncyAoJWx4LSVseCkiLAo+Pj4gKyAgICAg ICAgICAgIG5hbWUsIHYtPmhvc3RfZmVhdHVyZXMsIHN2cV9mZWF0dXJlcyk7Cj4+PiArICAgICAg ICByZXR1cm47Cj4+PiArICAgIH0gZWxzZSB7Cj4+PiArICAgICAgICAvKiBUT0RPOiBDaGVjayBm b3IgdmlydGlvX3ZkcGEgKyBJT01NVSAmIG1vZGVybiBkZXZpY2UgKi8KPj4KPj4gSSBndWVzcyB5 b3UgbWVhbiAidmhvc3RfdmRwYSIgaGVyZS4KPiBZZXMsIGEgc2ltaWxhciBtaXN0YWtlIGluIGxl c3MgdGhhbiA1MCBsaW5lcyA6KS4KPgo+PiBGb3IgSU9NTVUsIEkgZ3Vlc3MgeW91IG1lYW4gInZJ T01NVSIKPj4gYWN0dWFsbHk/Cj4+Cj4gVGhpcyBjb21tZW50IGlzIG91dCBvZiBkYXRlIGFuZCBp bmhlcml0ZWQgZnJvbSB0aGUgdmhvc3QgdmVyc2lvbiwKPiB3aGVyZSBvbmx5IHRoZSBJT01NVSB2 ZXJzaW9uIHdhcyBkZXZlbG9wZWQsIHNvIGl0IHdpbGwgYmUgZGVsZXRlZCBpbgo+IHRoZSBuZXh0 IHNlcmllcy4gSSB0aGluayBpdCBtYWtlcyBsaXR0bGUgc2Vuc2UgdG8gY2hlY2sgdklPTU1VIGlm IHdlCj4gc3RpY2sgd2l0aCB2RFBBIHNpbmNlIGl0IHN0aWxsIGRvZXMgbm90IHN1cHBvcnQgaXQs IGJ1dCB3ZSBjb3VsZCBtYWtlCj4gdGhlIGNoZWNrIGhlcmUgZm9yIHN1cmUuCgoKUmlnaHQuCgpU aGFua3MKCgo+Cj4gVGhhbmtzIQo+Cj4+IFRoYW5rcwo+Pgo+Pgo+Pj4gKyAgICB9Cj4+PiArCj4+ PiArICAgIGlmIChlcnJfY2F1c2UpIHsKPj4+ICsgICAgICAgIGdvdG8gZXJyOwo+Pj4gKyAgICB9 Cj4+PiArCj4+PiAgICAgICAgciA9IHZob3N0X3ZkcGFfZW5hYmxlX3N2cSh2LCBlbmFibGUpOwo+ Pj4gICAgICAgIGlmICh1bmxpa2VseSghcikpIHsKPj4+ICAgICAgICAgICAgZXJyX2NhdXNlID0g IkVycm9yIGVuYWJsaW5nIChzZWUgbW9uaXRvcikiOwo+Pj4gQEAgLTg1Myw3ICs5NTQsNyBAQCB2 b2lkIHFtcF94X3Zob3N0X2VuYWJsZV9zaGFkb3dfdnEoY29uc3QgY2hhciAqbmFtZSwgYm9vbCBl bmFibGUsIEVycm9yICoqZXJycCkKPj4+ICAgICAgICB9Cj4+Pgo+Pj4gICAgZXJyOgo+Pj4gLSAg ICBpZiAoZXJyX2NhdXNlKSB7Cj4+PiArICAgIGlmIChlcnJwID09IE5VTEwgJiYgZXJyX2NhdXNl KSB7Cj4+PiAgICAgICAgICAgIGVycm9yX3NldGcoZXJycCwgIkNhbid0IGVuYWJsZSBzaGFkb3cg dnEgb24gJXM6ICVzIiwgbmFtZSwgZXJyX2NhdXNlKTsKPj4+ICAgICAgICB9Cj4+PiAgICB9Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXph dGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5v cmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmly dHVhbGl6YXRpb24= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A3712C433F5 for ; Fri, 15 Oct 2021 05:03:00 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 0C89860E97 for ; Fri, 15 Oct 2021 05:03:00 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 0C89860E97 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=nongnu.org Received: from localhost ([::1]:35260 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1mbFMx-0001mZ-16 for qemu-devel@archiver.kernel.org; Fri, 15 Oct 2021 01:02:59 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:40434) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mbElG-0002ks-TO for qemu-devel@nongnu.org; Fri, 15 Oct 2021 00:24:03 -0400 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:46831) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1mbElA-0001q4-Rv for qemu-devel@nongnu.org; Fri, 15 Oct 2021 00:24:02 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1634271834; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Pig5QQjVrOL79mVmltr3kqNBr5fnBI51DbefzTjWym4=; b=Tiw/TdU03zkIsKc7YdG5181aQdzGAE6kGdl4zUisy3eYP87F6FBgdw3upisur7/Ou1SZlk sq/wGvEwmm58uV2/5kcWbtDdce5HiT5gzY1fFTbC3BLnklw1ukMFqOu0a+3Ub80QddBOl+ 0XcLMnonaoF/cWDxdi2lC/H7L6l8w6U= Received: from mail-pj1-f72.google.com (mail-pj1-f72.google.com [209.85.216.72]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-259-KF_deKgXNkyFHOgn7vNyKA-1; Fri, 15 Oct 2021 00:23:50 -0400 X-MC-Unique: KF_deKgXNkyFHOgn7vNyKA-1 Received: by mail-pj1-f72.google.com with SMTP id oc6-20020a17090b1c0600b001a0d6a48b8cso4196485pjb.6 for ; Thu, 14 Oct 2021 21:23:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=Pig5QQjVrOL79mVmltr3kqNBr5fnBI51DbefzTjWym4=; b=3Dj1Gd4gYXk/YIg7kfs3Wp0oWhqYN4lRgg6dHQVZT1Xj1hQaefUzi8wgkJANN5auQh 7dxrGOxFOQau0Yg6eQxlVqyIhn5qHiQH7IB8PuOb9xPl+o4l3lQ16U2lD1qxhM+69drW 4ZlFit307yLSeGUmTNt2JpEYDr5YDT8/nQ2GUFRY2nI8PeAGvbtngczpmFCK8/QFiwA/ rt8yqeb0OREkl+IMOlhlktsUqAc0UY2rAmXeQgKxmGZpGS2zI/ZK8B0RmzkUknMnnkbz xwJxbzqBxOEgMEKERNXKDvw3Aoaa4bthzYhw0OPHVHSeDfWkF8gN3sx9wEZ1zLvuV3p9 XRQQ== X-Gm-Message-State: AOAM531t0gLrI4VcCU6O0c+nFsSHMT/XjZ6LiweFXlBci2Cl06rQMvnQ 04uF0Ef9yeI7f+1n871cPLQR5bDog0Gf5njWuN0wgaueXjN2RxVWnUAPG9rLrREDYLXfiIWlWHt F1KTQ4tBopNMsAU4= X-Received: by 2002:a17:90b:694:: with SMTP id m20mr25430454pjz.160.1634271829338; Thu, 14 Oct 2021 21:23:49 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx9n9i6yJF6XnyAqRct9MWJATebG3DewQia8hyd/kJcrCrCDQRCnDHh59SsouEUkbLh+rP+TA== X-Received: by 2002:a17:90b:694:: with SMTP id m20mr25430381pjz.160.1634271828646; Thu, 14 Oct 2021 21:23:48 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id f20sm3611793pga.12.2021.10.14.21.23.43 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 14 Oct 2021 21:23:48 -0700 (PDT) Subject: Re: [RFC PATCH v4 15/20] vhost: Shadow virtqueue buffers forwarding To: Eugenio Perez Martin References: <20211001070603.307037-1-eperezma@redhat.com> <20211001070603.307037-16-eperezma@redhat.com> From: Jason Wang Message-ID: Date: Fri, 15 Oct 2021 12:23:42 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.14.0 MIME-Version: 1.0 In-Reply-To: Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Received-SPF: pass client-ip=216.205.24.124; envelope-from=jasowang@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -28 X-Spam_score: -2.9 X-Spam_bar: -- X-Spam_report: (-2.9 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.049, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, NICE_REPLY_A=-0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Parav Pandit , Juan Quintela , Markus Armbruster , "Michael S. Tsirkin" , qemu-level , virtualization , Harpreet Singh Anand , Xiao W Wang , Stefan Hajnoczi , Eli Cohen , Eric Blake , Michael Lilja , Stefano Garzarella Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" 在 2021/10/15 上午1:56, Eugenio Perez Martin 写道: > On Wed, Oct 13, 2021 at 6:31 AM Jason Wang wrote: >> >> 在 2021/10/1 下午3:05, Eugenio Pérez 写道: >>> Initial version of shadow virtqueue that actually forward buffers. There >>> are no iommu support at the moment, and that will be addressed in future >>> patches of this series. Since all vhost-vdpa devices uses forced IOMMU, >>> this means that SVQ is not usable at this point of the series on any >>> device. >>> >>> For simplicity it only supports modern devices, that expects vring >>> in little endian, with split ring and no event idx or indirect >>> descriptors. Support for them will not be added in this series. >>> >>> It reuses the VirtQueue code for the device part. The driver part is >>> based on Linux's virtio_ring driver, but with stripped functionality >>> and optimizations so it's easier to review. Later commits add simpler >>> ones. >>> >>> SVQ uses VIRTIO_CONFIG_S_DEVICE_STOPPED to pause the device and >>> retrieve its status (next available idx the device was going to >>> consume) race-free. It can later reset the device to replace vring >>> addresses etc. When SVQ starts qemu can resume consuming the guest's >>> driver ring from that state, without notice from the latter. >>> >>> This status bit VIRTIO_CONFIG_S_DEVICE_STOPPED is currently discussed >>> in VirtIO, and is implemented in qemu VirtIO-net devices in previous >>> commits. >>> >>> Removal of _S_DEVICE_STOPPED bit (in other words, resuming the device) >>> can be done in the future if an use case arises. At this moment we can >>> just rely on reseting the full device. >>> >>> Signed-off-by: Eugenio Pérez >>> --- >>> qapi/net.json | 2 +- >>> hw/virtio/vhost-shadow-virtqueue.c | 237 ++++++++++++++++++++++++++++- >>> hw/virtio/vhost-vdpa.c | 109 ++++++++++++- >>> 3 files changed, 337 insertions(+), 11 deletions(-) >>> >>> diff --git a/qapi/net.json b/qapi/net.json >>> index fe546b0e7c..1f4a55f2c5 100644 >>> --- a/qapi/net.json >>> +++ b/qapi/net.json >>> @@ -86,7 +86,7 @@ >>> # >>> # @name: the device name of the VirtIO device >>> # >>> -# @enable: true to use the alternate shadow VQ notifications >>> +# @enable: true to use the alternate shadow VQ buffers fowarding path >>> # >>> # Returns: Error if failure, or 'no error' for success. >>> # >>> diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c >>> index 34e159d4fd..df7e6fa3ec 100644 >>> --- a/hw/virtio/vhost-shadow-virtqueue.c >>> +++ b/hw/virtio/vhost-shadow-virtqueue.c >>> @@ -10,6 +10,7 @@ >>> #include "qemu/osdep.h" >>> #include "hw/virtio/vhost-shadow-virtqueue.h" >>> #include "hw/virtio/vhost.h" >>> +#include "hw/virtio/virtio-access.h" >>> >>> #include "standard-headers/linux/vhost_types.h" >>> >>> @@ -44,15 +45,135 @@ typedef struct VhostShadowVirtqueue { >>> >>> /* Virtio device */ >>> VirtIODevice *vdev; >>> + >>> + /* Map for returning guest's descriptors */ >>> + VirtQueueElement **ring_id_maps; >>> + >>> + /* Next head to expose to device */ >>> + uint16_t avail_idx_shadow; >>> + >>> + /* Next free descriptor */ >>> + uint16_t free_head; >>> + >>> + /* Last seen used idx */ >>> + uint16_t shadow_used_idx; >>> + >>> + /* Next head to consume from device */ >>> + uint16_t used_idx; >> >> Let's use "last_used_idx" as kernel driver did. >> > Ok I will change it. > >>> } VhostShadowVirtqueue; >>> >>> /* If the device is using some of these, SVQ cannot communicate */ >>> bool vhost_svq_valid_device_features(uint64_t *dev_features) >>> { >>> - return true; >>> + uint64_t b; >>> + bool r = true; >>> + >>> + for (b = VIRTIO_TRANSPORT_F_START; b <= VIRTIO_TRANSPORT_F_END; ++b) { >>> + switch (b) { >>> + case VIRTIO_F_NOTIFY_ON_EMPTY: >>> + case VIRTIO_F_ANY_LAYOUT: >>> + /* SVQ is fine with this feature */ >>> + continue; >>> + >>> + case VIRTIO_F_ACCESS_PLATFORM: >>> + /* SVQ needs this feature disabled. Can't continue */ >> >> So code can explain itself, need a comment to explain why. >> > Do you mean that it *doesn't* need a comment to explain why? In that > case I will delete them. I meant the comment is duplicated with the code. If you wish, you can explain why ACCESS_PLATFORM needs to be disabled. > >>> + if (*dev_features & BIT_ULL(b)) { >>> + clear_bit(b, dev_features); >>> + r = false; >>> + } >>> + break; >>> + >>> + case VIRTIO_F_VERSION_1: >>> + /* SVQ needs this feature, so can't continue */ >> >> A comment to explain why SVQ needs this feature. >> > Sure I will add it. > >>> + if (!(*dev_features & BIT_ULL(b))) { >>> + set_bit(b, dev_features); >>> + r = false; >>> + } >>> + continue; >>> + >>> + default: >>> + /* >>> + * SVQ must disable this feature, let's hope the device is fine >>> + * without it. >>> + */ >>> + if (*dev_features & BIT_ULL(b)) { >>> + clear_bit(b, dev_features); >>> + } >>> + } >>> + } >>> + >>> + return r; >>> +} >> >> Let's move this to patch 14. >> > I can move it down to 14/20, but then it is not really accurate, since > notifications forwarding can work with all feature sets. Not like we > are introducing a regression, but still. > > I can always explain that in the patch message though, would that be ok? I'm afraid this will break bisection. E.g for patch 14, it works for any features but for patch 15 it doesn't. > >>> + >>> +static void vhost_vring_write_descs(VhostShadowVirtqueue *svq, >>> + const struct iovec *iovec, >>> + size_t num, bool more_descs, bool write) >>> +{ >>> + uint16_t i = svq->free_head, last = svq->free_head; >>> + unsigned n; >>> + uint16_t flags = write ? cpu_to_le16(VRING_DESC_F_WRITE) : 0; >>> + vring_desc_t *descs = svq->vring.desc; >>> + >>> + if (num == 0) { >>> + return; >>> + } >>> + >>> + for (n = 0; n < num; n++) { >>> + if (more_descs || (n + 1 < num)) { >>> + descs[i].flags = flags | cpu_to_le16(VRING_DESC_F_NEXT); >>> + } else { >>> + descs[i].flags = flags; >>> + } >>> + descs[i].addr = cpu_to_le64((hwaddr)iovec[n].iov_base); >>> + descs[i].len = cpu_to_le32(iovec[n].iov_len); >>> + >>> + last = i; >>> + i = cpu_to_le16(descs[i].next); >>> + } >>> + >>> + svq->free_head = le16_to_cpu(descs[last].next); >>> +} >>> + >>> +static unsigned vhost_svq_add_split(VhostShadowVirtqueue *svq, >>> + VirtQueueElement *elem) >>> +{ >>> + int head; >>> + unsigned avail_idx; >>> + vring_avail_t *avail = svq->vring.avail; >>> + >>> + head = svq->free_head; >>> + >>> + /* We need some descriptors here */ >>> + assert(elem->out_num || elem->in_num); >>> + >>> + vhost_vring_write_descs(svq, elem->out_sg, elem->out_num, >>> + elem->in_num > 0, false); >>> + vhost_vring_write_descs(svq, elem->in_sg, elem->in_num, false, true); >>> + >>> + /* >>> + * Put entry in available array (but don't update avail->idx until they >>> + * do sync). >>> + */ >>> + avail_idx = svq->avail_idx_shadow & (svq->vring.num - 1); >>> + avail->ring[avail_idx] = cpu_to_le16(head); >>> + svq->avail_idx_shadow++; >>> + >>> + /* Update avail index after the descriptor is wrote */ >>> + smp_wmb(); >>> + avail->idx = cpu_to_le16(svq->avail_idx_shadow); >>> + >>> + return head; >>> + >>> } >>> >>> -/* Forward guest notifications */ >>> +static void vhost_svq_add(VhostShadowVirtqueue *svq, VirtQueueElement *elem) >>> +{ >>> + unsigned qemu_head = vhost_svq_add_split(svq, elem); >>> + >>> + svq->ring_id_maps[qemu_head] = elem; >>> +} >>> + >>> +/* Handle guest->device notifications */ >>> static void vhost_handle_guest_kick(EventNotifier *n) >>> { >>> VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, >>> @@ -62,7 +183,74 @@ static void vhost_handle_guest_kick(EventNotifier *n) >>> return; >>> } >>> >>> - event_notifier_set(&svq->kick_notifier); >>> + /* Make available as many buffers as possible */ >>> + do { >>> + if (virtio_queue_get_notification(svq->vq)) { >>> + /* No more notifications until process all available */ >>> + virtio_queue_set_notification(svq->vq, false); >>> + } >> >> This can be done outside the loop. >> > I think it cannot. The intention of doing this way is that we check > for new available buffers *also after* enabling notifications, so we > don't miss any of them. It is more or less copied from > virtio_blk_handle_vq, which also needs to run to completion. > > If we need to loop again because there are more available buffers, we > want to disable notifications again. Or am I missing something? I think you're right. > >>> + >>> + while (true) { >>> + VirtQueueElement *elem = virtqueue_pop(svq->vq, sizeof(*elem)); >>> + if (!elem) { >>> + break; >>> + } >>> + >>> + vhost_svq_add(svq, elem); >>> + event_notifier_set(&svq->kick_notifier); >>> + } >>> + >>> + virtio_queue_set_notification(svq->vq, true); >> >> I think this can be moved to the end of this function. >> > (Same as previous answer) > >> Btw, we probably need a quota to make sure the svq is not hogging the >> main event loop. >> >> Similar issue could be found in both virtio-net TX (using timer or bh) >> and TAP (a quota). >> > I think that virtqueue size is the natural limit to that: since we are > not making any buffers used in the loop, there is no way that it runs > more than virtqueue size times. If it does because of an evil/bogus > guest, virtqueue_pop raises the message "Virtqueue size exceeded" and > returns NULL, effectively breaking the loop. > > Virtio-net tx functions mark each buffer right after making them > available and use it, so they can hog BQL. But my understanding is > that is not possible in the SVQ case. Right. > > I can add a comment in the code to make it clearer though. Yes, please. > >>> + } while (!virtio_queue_empty(svq->vq)); >>> +} >>> + >>> +static bool vhost_svq_more_used(VhostShadowVirtqueue *svq) >>> +{ >>> + if (svq->used_idx != svq->shadow_used_idx) { >>> + return true; >>> + } >>> + >>> + /* Get used idx must not be reordered */ >>> + smp_rmb(); >> >> Interesting, we don't do this for kernel drivers. It would be helpful to >> explain it more clear by "X must be done before Y". >> > I think this got reordered, it's supposed to be *after* get the used > idx, so it matches the one in the kernel with the comment "Only get > used array entries after they have been exposed by host.". Right. > > I will change it for the next series. Ok. > >>> + svq->shadow_used_idx = cpu_to_le16(svq->vring.used->idx); >>> + >>> + return svq->used_idx != svq->shadow_used_idx; >>> +} >>> + >>> +static VirtQueueElement *vhost_svq_get_buf(VhostShadowVirtqueue *svq) >>> +{ >>> + vring_desc_t *descs = svq->vring.desc; >>> + const vring_used_t *used = svq->vring.used; >>> + vring_used_elem_t used_elem; >>> + uint16_t last_used; >>> + >>> + if (!vhost_svq_more_used(svq)) { >>> + return NULL; >>> + } >>> + >>> + last_used = svq->used_idx & (svq->vring.num - 1); >>> + used_elem.id = le32_to_cpu(used->ring[last_used].id); >>> + used_elem.len = le32_to_cpu(used->ring[last_used].len); >>> + >>> + svq->used_idx++; >>> + if (unlikely(used_elem.id >= svq->vring.num)) { >>> + error_report("Device %s says index %u is used", svq->vdev->name, >>> + used_elem.id); >>> + return NULL; >>> + } >>> + >>> + if (unlikely(!svq->ring_id_maps[used_elem.id])) { >>> + error_report( >>> + "Device %s says index %u is used, but it was not available", >>> + svq->vdev->name, used_elem.id); >>> + return NULL; >>> + } >>> + >>> + descs[used_elem.id].next = svq->free_head; >>> + svq->free_head = used_elem.id; >>> + >>> + svq->ring_id_maps[used_elem.id]->len = used_elem.len; >>> + return g_steal_pointer(&svq->ring_id_maps[used_elem.id]); >>> } >>> >>> /* Forward vhost notifications */ >>> @@ -70,8 +258,26 @@ static void vhost_svq_handle_call_no_test(EventNotifier *n) >>> { >>> VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, >>> call_notifier); >>> - >>> - event_notifier_set(&svq->guest_call_notifier); >>> + VirtQueue *vq = svq->vq; >>> + >>> + /* Make as many buffers as possible used. */ >>> + do { >>> + unsigned i = 0; >>> + >>> + /* TODO: Use VRING_AVAIL_F_NO_INTERRUPT */ >>> + while (true) { >>> + g_autofree VirtQueueElement *elem = vhost_svq_get_buf(svq); >>> + if (!elem) { >>> + break; >>> + } >>> + >>> + assert(i < svq->vring.num); >> >> Let's return error instead of using the assert. >> > Actually this is a condition that we should never meet: In the case of > ring overrun, device would try to set used a descriptor that is either >> vring size *or* should try to overrun some of the already used ones. > In both cases, elem should be NULL and the loop should break. > > So this is a safety net protecting from both, if we have an i > > svq->vring.num means we are not processing used buffers well anymore, > and (moreover) this is happening after making used all descriptors. > > Taking that into account, should we delete it? Maybe a warning instead. > >>> + virtqueue_fill(vq, elem, elem->len, i++); >>> + } >>> + >>> + virtqueue_flush(vq, i); >>> + event_notifier_set(&svq->guest_call_notifier); >>> + } while (vhost_svq_more_used(svq)); >>> } >>> >>> static void vhost_svq_handle_call(EventNotifier *n) >>> @@ -204,12 +410,25 @@ err_set_vring_kick: >>> void vhost_svq_stop(struct vhost_dev *dev, unsigned idx, >>> VhostShadowVirtqueue *svq) >>> { >>> + int i; >>> int r = vhost_svq_restore_vdev_host_notifier(dev, idx, svq); >>> + >>> if (unlikely(r < 0)) { >>> error_report("Couldn't restore vq kick fd: %s", strerror(-r)); >>> } >>> >>> event_notifier_set_handler(&svq->host_notifier, NULL); >>> + >>> + for (i = 0; i < svq->vring.num; ++i) { >>> + g_autofree VirtQueueElement *elem = svq->ring_id_maps[i]; >>> + /* >>> + * Although the doc says we must unpop in order, it's ok to unpop >>> + * everything. >>> + */ >>> + if (elem) { >>> + virtqueue_unpop(svq->vq, elem, elem->len); >>> + } >> >> Will this result some of the "pending" buffers to be submitted multiple >> times? If yes, should we wait for all the buffers used instead of doing >> the unpop here? >> > Do you mean to call virtqueue_unpop with the same elem (or elem.id) > multiple times? That should never happen, because elem.id should be > the position in the ring_id_maps. Also, unpop() should just unmap the > element and never sync again. > > Maybe it is way clearer to call virtqueue_detach_element here directly. I meant basically for the buffers that were consumed by the device but not made used. In this case if we unpop here. It will be processed by the device later via vhost-vdpa again? This is probably fine for net but I'm not sure it works for other devices. Another way is to wait until all the consumed buffer used. > >>> + } >>> } >>> >>> /* >>> @@ -224,7 +443,7 @@ VhostShadowVirtqueue *vhost_svq_new(struct vhost_dev *dev, int idx) >>> size_t driver_size; >>> size_t device_size; >>> g_autofree VhostShadowVirtqueue *svq = g_new0(VhostShadowVirtqueue, 1); >>> - int r; >>> + int r, i; >>> >>> r = event_notifier_init(&svq->kick_notifier, 0); >>> if (r != 0) { >>> @@ -250,6 +469,11 @@ VhostShadowVirtqueue *vhost_svq_new(struct vhost_dev *dev, int idx) >>> memset(svq->vring.desc, 0, driver_size); >>> svq->vring.used = qemu_memalign(qemu_real_host_page_size, device_size); >>> memset(svq->vring.used, 0, device_size); >>> + for (i = 0; i < num - 1; i++) { >>> + svq->vring.desc[i].next = cpu_to_le16(i + 1); >>> + } >>> + >>> + svq->ring_id_maps = g_new0(VirtQueueElement *, num); >>> event_notifier_set_handler(&svq->call_notifier, >>> vhost_svq_handle_call); >>> return g_steal_pointer(&svq); >>> @@ -269,6 +493,7 @@ void vhost_svq_free(VhostShadowVirtqueue *vq) >>> event_notifier_cleanup(&vq->kick_notifier); >>> event_notifier_set_handler(&vq->call_notifier, NULL); >>> event_notifier_cleanup(&vq->call_notifier); >>> + g_free(vq->ring_id_maps); >>> qemu_vfree(vq->vring.desc); >>> qemu_vfree(vq->vring.used); >>> g_free(vq); >>> diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c >>> index a057e8277d..bb7010ddb5 100644 >>> --- a/hw/virtio/vhost-vdpa.c >>> +++ b/hw/virtio/vhost-vdpa.c >>> @@ -19,6 +19,7 @@ >>> #include "hw/virtio/virtio-net.h" >>> #include "hw/virtio/vhost-shadow-virtqueue.h" >>> #include "hw/virtio/vhost-vdpa.h" >>> +#include "hw/virtio/vhost-shadow-virtqueue.h" >>> #include "exec/address-spaces.h" >>> #include "qemu/main-loop.h" >>> #include "cpu.h" >>> @@ -475,6 +476,28 @@ static int vhost_vdpa_set_features(struct vhost_dev *dev, >>> return vhost_vdpa_backend_set_features(dev, features); >>> } >>> >>> +/** >>> + * Restore guest features to vdpa device >>> + */ >>> +static int vhost_vdpa_set_guest_features(struct vhost_dev *dev) >>> +{ >>> + struct vhost_vdpa *v = dev->opaque; >>> + return vhost_vdpa_backend_set_features(dev, v->guest_features); >>> +} >>> + >>> +/** >>> + * Set shadow virtqueue supported features >>> + */ >>> +static int vhost_vdpa_set_svq_features(struct vhost_dev *dev) >>> +{ >>> + struct vhost_vdpa *v = dev->opaque; >>> + uint64_t features = v->host_features; >>> + bool b = vhost_svq_valid_device_features(&features); >>> + assert(b); >>> + >>> + return vhost_vdpa_backend_set_features(dev, features); >>> +} >>> + >>> static int vhost_vdpa_set_backend_cap(struct vhost_dev *dev) >>> { >>> uint64_t features; >>> @@ -730,6 +753,19 @@ static bool vhost_vdpa_force_iommu(struct vhost_dev *dev) >>> return true; >>> } >>> >>> +static int vhost_vdpa_vring_pause(struct vhost_dev *dev) >>> +{ >>> + int r; >>> + uint8_t status; >>> + >>> + vhost_vdpa_add_status(dev, VIRTIO_CONFIG_S_DEVICE_STOPPED); >>> + do { >>> + r = vhost_vdpa_call(dev, VHOST_VDPA_GET_STATUS, &status); >> >> I guess we'd better add some sleep here. >> > If the final version still contains the call, I will add the sleep. At > the moment I think it's better if we stop the device by a vdpa ioctl. Ok, so the idea is to sleep in the ioctl? > >>> + } while (r == 0 && !(status & VIRTIO_CONFIG_S_DEVICE_STOPPED)); >>> + >>> + return 0; >>> +} >>> + >>> /* >>> * Start shadow virtqueue. >>> */ >>> @@ -742,9 +778,29 @@ static bool vhost_vdpa_svq_start_vq(struct vhost_dev *dev, unsigned idx) >>> .index = idx + dev->vq_index, >>> .fd = event_notifier_get_fd(vhost_call_notifier), >>> }; >>> + struct vhost_vring_addr addr = { >>> + .index = idx + dev->vq_index, >>> + }; >>> + struct vhost_vring_state num = { >>> + .index = idx + dev->vq_index, >>> + .num = virtio_queue_get_num(dev->vdev, idx), >>> + }; >>> int r; >>> bool b; >>> >>> + vhost_svq_get_vring_addr(svq, &addr); >>> + r = vhost_vdpa_set_vring_addr(dev, &addr); >>> + if (unlikely(r)) { >>> + error_report("vhost_set_vring_addr for shadow vq failed"); >>> + return false; >>> + } >>> + >>> + r = vhost_vdpa_set_vring_num(dev, &num); >>> + if (unlikely(r)) { >>> + error_report("vhost_vdpa_set_vring_num for shadow vq failed"); >>> + return false; >>> + } >>> + >>> /* Set shadow vq -> guest notifier */ >>> assert(v->call_fd[idx]); >>> vhost_svq_set_guest_call_notifier(svq, v->call_fd[idx]); >>> @@ -781,15 +837,32 @@ static unsigned vhost_vdpa_enable_svq(struct vhost_vdpa *v, bool enable) >>> assert(v->shadow_vqs->len == 0); >>> for (n = 0; n < hdev->nvqs; ++n) { >>> VhostShadowVirtqueue *svq = vhost_svq_new(hdev, n); >>> - bool ok; >>> - >>> if (unlikely(!svq)) { >>> g_ptr_array_set_size(v->shadow_vqs, 0); >>> return 0; >>> } >>> g_ptr_array_add(v->shadow_vqs, svq); >>> + } >>> + } >>> >>> - ok = vhost_vdpa_svq_start_vq(hdev, n); >>> + r = vhost_vdpa_vring_pause(hdev); >>> + assert(r == 0); >>> + >>> + if (enable) { >>> + for (n = 0; n < v->shadow_vqs->len; ++n) { >>> + /* Obtain Virtqueue state */ >>> + vhost_virtqueue_stop(hdev, hdev->vdev, &hdev->vqs[n], n); >>> + } >>> + } >>> + >>> + /* Reset device so it can be configured */ >>> + r = vhost_vdpa_dev_start(hdev, false); >>> + assert(r == 0); >>> + >>> + if (enable) { >>> + int r; >>> + for (n = 0; n < v->shadow_vqs->len; ++n) { >>> + bool ok = vhost_vdpa_svq_start_vq(hdev, n); >>> if (unlikely(!ok)) { >>> /* Free still not started svqs */ >>> g_ptr_array_set_size(v->shadow_vqs, n); >>> @@ -797,11 +870,19 @@ static unsigned vhost_vdpa_enable_svq(struct vhost_vdpa *v, bool enable) >>> break; >>> } >>> } >>> + >>> + /* Need to ack features to set state in vp_vdpa devices */ >> >> vhost_vdpa actually? >> > Yes, what a mistake! > >>> + r = vhost_vdpa_set_svq_features(hdev); >>> + if (unlikely(r)) { >>> + enable = false; >>> + } >>> } >>> >>> v->shadow_vqs_enabled = enable; >>> >>> if (!enable) { >>> + vhost_vdpa_set_guest_features(hdev); >>> + >>> /* Disable all queues or clean up failed start */ >>> for (n = 0; n < v->shadow_vqs->len; ++n) { >>> struct vhost_vring_file file = { >>> @@ -818,7 +899,12 @@ static unsigned vhost_vdpa_enable_svq(struct vhost_vdpa *v, bool enable) >>> /* TODO: This can unmask or override call fd! */ >>> vhost_virtqueue_start(hdev, hdev->vdev, &hdev->vqs[n], vq_idx); >>> } >>> + } >>> >>> + r = vhost_vdpa_dev_start(hdev, true); >>> + assert(r == 0); >>> + >>> + if (!enable) { >>> /* Resources cleanup */ >>> g_ptr_array_set_size(v->shadow_vqs, 0); >>> } >>> @@ -831,6 +917,7 @@ void qmp_x_vhost_enable_shadow_vq(const char *name, bool enable, Error **errp) >>> struct vhost_vdpa *v; >>> const char *err_cause = NULL; >>> bool r; >>> + uint64_t svq_features; >>> >>> QLIST_FOREACH(v, &vhost_vdpa_devices, entry) { >>> if (v->dev->vdev && 0 == strcmp(v->dev->vdev->name, name)) { >>> @@ -846,6 +933,20 @@ void qmp_x_vhost_enable_shadow_vq(const char *name, bool enable, Error **errp) >>> goto err; >>> } >>> >>> + svq_features = v->host_features; >>> + if (!vhost_svq_valid_device_features(&svq_features)) { >>> + error_setg(errp, >>> + "Can't enable shadow vq on %s: Unexpected feature flags (%lx-%lx)", >>> + name, v->host_features, svq_features); >>> + return; >>> + } else { >>> + /* TODO: Check for virtio_vdpa + IOMMU & modern device */ >> >> I guess you mean "vhost_vdpa" here. > Yes, a similar mistake in less than 50 lines :). > >> For IOMMU, I guess you mean "vIOMMU" >> actually? >> > This comment is out of date and inherited from the vhost version, > where only the IOMMU version was developed, so it will be deleted in > the next series. I think it makes little sense to check vIOMMU if we > stick with vDPA since it still does not support it, but we could make > the check here for sure. Right. Thanks > > Thanks! > >> Thanks >> >> >>> + } >>> + >>> + if (err_cause) { >>> + goto err; >>> + } >>> + >>> r = vhost_vdpa_enable_svq(v, enable); >>> if (unlikely(!r)) { >>> err_cause = "Error enabling (see monitor)"; >>> @@ -853,7 +954,7 @@ void qmp_x_vhost_enable_shadow_vq(const char *name, bool enable, Error **errp) >>> } >>> >>> err: >>> - if (err_cause) { >>> + if (errp == NULL && err_cause) { >>> error_setg(errp, "Can't enable shadow vq on %s: %s", name, err_cause); >>> } >>> }