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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id 33F23C433EF for ; Fri, 22 Apr 2022 09:12:11 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id CA1FE8409D; Fri, 22 Apr 2022 09:12:10 +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 Mtv4rHwzNDzB; Fri, 22 Apr 2022 09:12:09 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [IPv6:2605:bc80:3010:104::8cd3:938]) by smtp1.osuosl.org (Postfix) with ESMTPS id 6F68E84096; Fri, 22 Apr 2022 09:12:08 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 33E30C0032; Fri, 22 Apr 2022 09:12:08 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id 2FD66C002D for ; Fri, 22 Apr 2022 09:12:07 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id 158198409A for ; Fri, 22 Apr 2022 09:12:07 +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 fzY1bvIfyS0C for ; Fri, 22 Apr 2022 09:12:05 +0000 (UTC) X-Greylist: whitelisted by SQLgrey-1.8.0 Received: from mail-pf1-x435.google.com (mail-pf1-x435.google.com [IPv6:2607:f8b0:4864:20::435]) by smtp1.osuosl.org (Postfix) with ESMTPS id 65E4884096 for ; Fri, 22 Apr 2022 09:12:05 +0000 (UTC) Received: by mail-pf1-x435.google.com with SMTP id a15so7415162pfv.11 for ; Fri, 22 Apr 2022 02:12:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=message-id:date:mime-version:user-agent:subject:content-language:to :cc:references:from:in-reply-to:content-transfer-encoding; bh=3hPshux/9mpgfrkX7ChnlAe//9FupZFlffa+u2LwKpM=; b=xTvCgxufTFlMC/sf7og0zUG1bRyD+jrunR+CqasxGc8nBYbtis0rfo1qv3Orb286d9 c+L/DCifYwicRQhgwlkSQQN7q31/7jkieLw/Z5xSwpBk363OnbhL0yMqT5D5E+C4WEXA lZGN7RujL5sW4JXxYfmJcYmK2MNEoy7v/pmFxZ8ILycSm082vKS0bO1l8GHCF8Se5Yep q25uFnEhXAgHLu36N2gNS+m20uHdadTrgQBMydXsIQ4JbWeSMqa3d7bK07+78rZbCZ/O Vdw3/hxm5nc88ziGhrzEWYw9EpyARQOe3fhDyKRk/MBxoKHyqZeOA9rcHT2I9hEb1FDy +kgg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to :content-transfer-encoding; bh=3hPshux/9mpgfrkX7ChnlAe//9FupZFlffa+u2LwKpM=; b=0awrk9He8g0miKGIdJ2aEY1wcvNtB29n4evnUuR8cOaJrXw9J8UCHXKFaVB1SjmoLi AhxiOSNlQAjeMAiGAm0AnqVOn9BFePlzBXdez34TloYc4p0IjxsCa5pOUudYthsLc+Bb 0jMsTZl8kC/za/EecNJkr5Sn9GaPLNHCrwipIiNAlK4x3SLjG5GfhE2v4pzPv/ST9SPP JjxTB8oitboIwivJWq6bL4upqZJWCKyca4H3wF4k8xtWQnfn6rHWCZu7perDj6DAbPNg soggSE4/SuNM7YYS6+qQ0xUGmck8g7XHATU303GC8dcFK8u7YnzhVvtdjUo8fZu8Zj1d +6Sg== X-Gm-Message-State: AOAM532qHP4XWSYivr6TF1sXi8/8hxyGmCX/47n60LUKONIjEZo3w1tA 291G26tOyO0+K+h6d4vVv/JDLw== X-Google-Smtp-Source: ABdhPJxuGB3YAK/6R1hHmiKbFnv6kqR2cpmryF9yAyjF3GRPg2W6rJcxjTdcdtDe82SsMMhxkTIMJw== X-Received: by 2002:a63:4101:0:b0:3aa:6375:e5f4 with SMTP id o1-20020a634101000000b003aa6375e5f4mr3089276pga.240.1650618724758; Fri, 22 Apr 2022 02:12:04 -0700 (PDT) Received: from [10.76.15.169] ([61.120.150.70]) by smtp.gmail.com with ESMTPSA id c16-20020a631c50000000b003a39244fe8esm1572546pgm.68.2022.04.22.02.12.00 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 22 Apr 2022 02:12:04 -0700 (PDT) Message-ID: Date: Fri, 22 Apr 2022 17:08:13 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.7.0 Subject: Re: Re: [PATCH v3 1/5] virtio-crypto: use private buffer for control request Content-Language: en-US To: Jason Wang , arei.gonglei@huawei.com, mst@redhat.com References: <20220421104016.453458-1-pizhenwei@bytedance.com> <20220421104016.453458-2-pizhenwei@bytedance.com> <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> From: zhenwei pi In-Reply-To: <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> Cc: helei.sig11@bytedance.com, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, linux-crypto@vger.kernel.org, davem@davemloft.net, herbert@gondor.apana.org.au 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" T24gNC8yMi8yMiAxNTo0MSwgSmFzb24gV2FuZyB3cm90ZToKPiAKPiDlnKggMjAyMi80LzIxIDE4 OjQwLCB6aGVud2VpIHBpIOWGmemBkzoKPj4gT3JpZ2luYWxseSwgYWxsIG9mIHRoZSBjb250cm9s IHJlcXVlc3RzIHNoYXJlIGEgc2luZ2xlIGJ1ZmZlcigKPj4gY3RybCAmIGlucHV0ICYgY3RybF9z dGF0dXMgZmllbGRzIGluIHN0cnVjdCB2aXJ0aW9fY3J5cHRvKSwgdGhpcwo+PiBhbGxvd3MgcXVl dWUgZGVwdGggMSBvbmx5LCB0aGUgcGVyZm9ybWFuY2Ugb2YgY29udHJvbCBxdWV1ZSBnZXRzCj4+ IGxpbWl0ZWQgYnkgdGhpcyBkZXNpZ24uCj4+Cj4+IEluIHRoaXMgcGF0Y2gsIGVhY2ggcmVxdWVz dCBhbGxvY2F0ZXMgcmVxdWVzdCBidWZmZXIgZHluYW1pY2FsbHksIGFuZAo+PiBmcmVlIGJ1ZmZl ciBhZnRlciByZXF1ZXN0LCBpdCdzIHBvc3NpYmxlIHRvIG9wdGltaXplIGNvbnRyb2wgcXVldWUK Pj4gZGVwdGggaW4gdGhlIG5leHQgc3RlcC4KPj4KPj4gQSBuZWNlc3NhcnkgY29tbWVudCBpcyBh bHJlYWR5IGluIGNvZGUsIHN0aWxsIGRlc2NyaWJlIGl0IGFnYWluOgo+PiAvKgo+PiDCoCAqIE5v dGU6IHRoZXJlIGFyZSBwYWRkaW5nIGZpZWxkcyBpbiByZXF1ZXN0LCBjbGVhciB0aGVtIHRvIHpl cm8gYmVmb3JlCj4+IMKgICogc2VuZGluZyB0byBob3N0LAo+PiDCoCAqIEV4LCB2aXJ0aW9fY3J5 cHRvX2N0cmxfcmVxdWVzdDo6Y3RybDo6dTo6ZGVzdHJveV9zZXNzaW9uOjpwYWRkaW5nWzQ4XQo+ PiDCoCAqLwo+PiBTbyB1c2Uga3phbGxvYyB0byBhbGxvY2F0ZSBidWZmZXIgb2Ygc3RydWN0IHZp cnRpb19jcnlwdG9fY3RybF9yZXF1ZXN0Lgo+Pgo+PiBDYzogTWljaGFlbCBTLiBUc2lya2luIDxt c3RAcmVkaGF0LmNvbT4KPj4gQ2M6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Cj4+ IENjOiBHb25nbGVpIDxhcmVpLmdvbmdsZWlAaHVhd2VpLmNvbT4KPj4gU2lnbmVkLW9mZi1ieTog emhlbndlaSBwaSA8cGl6aGVud2VpQGJ5dGVkYW5jZS5jb20+Cj4+IC0tLQo+PiDCoCBkcml2ZXJz L2NyeXB0by92aXJ0aW8vTWFrZWZpbGXCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfMKg wqAgMSArCj4+IMKgIC4uLi92aXJ0aW8vdmlydGlvX2NyeXB0b19ha2NpcGhlcl9hbGdzLmPCoMKg wqDCoMKgIHzCoCA5MCArKysrKystLS0tLS0KPj4gwqAgZHJpdmVycy9jcnlwdG8vdmlydGlvL3Zp cnRpb19jcnlwdG9fY29tbW9uLmPCoCB8wqAgMzkgKysrKysKPiAKPiAKPiBBbnkgcmVhc29uIHdl IGNhbid0IHVzZSB2aXJ0aW9fY3J5cHRvX2NvcmUuYz8KPiAKQW5vdGhlciBwYXRjaCBpbiB0aGlz IHNlcmllczogW1BBVENIIHYzIDMvNV0gdmlydGlvLWNyeXB0bzogbW92ZSBoZWxwZXJzIAppbnRv IHZpcnRpb19jcnlwdG9fY29tbW9uLmMKCk1vdmUgdmlydGNyeXB0b19jbGVhcl9yZXF1ZXN0IGFu ZCB2aXJ0Y3J5cHRvX2RhdGFxX2NhbGxiYWNrIGludG8KdmlydGlvX2NyeXB0b19jb21tb24uYyB0 byBtYWtlIGNvZGUgY2xlYXIuIFRoZW4gdGhlIHh4X2NvcmUuYwpzdXBwb3J0czoKICAgLSBwcm9i ZS9yZW1vdmUvaXJxIGFmZmluaXR5IHNldGluZyBmb3IgYSB2aXJ0aW8gZGV2aWNlCiAgIC0gYmFz aWMgdmlydGlvIHJlbGF0ZWQgb3BlcmF0aW9ucwoKeHhfY29tbW9uLmMgc3VwcG9ydHM6CiAgIC0g Y29tbW9uIGhlbHBlcnMvZnVuY3Rpb25zIGZvciBhbGdvcwoKU28gSSBwdXQgdGhpcyBpbnRvIGEg bmV3IGZpbGUuCgo+IAo+PiDCoCBkcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0b19j b21tb24uaMKgIHzCoCAxOSArKy0KPj4gwqAgLi4uL3ZpcnRpby92aXJ0aW9fY3J5cHRvX3NrY2lw aGVyX2FsZ3MuY8KgwqDCoMKgwqAgfCAxMzMgKysrKysrKystLS0tLS0tLS0tCj4+IMKgIDUgZmls ZXMgY2hhbmdlZCwgMTU2IGluc2VydGlvbnMoKyksIDEyNiBkZWxldGlvbnMoLSkKPj4gwqAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1v bi5jCj4+Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vTWFrZWZpbGUgCj4+ IGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL01ha2VmaWxlCj4+IGluZGV4IGJmYTZjYmFlMzQyZS4u NDljMWZhODBlNDY1IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vTWFrZWZp bGUKPj4gKysrIGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL01ha2VmaWxlCj4+IEBAIC0zLDUgKzMs NiBAQCBvYmotJChDT05GSUdfQ1JZUFRPX0RFVl9WSVJUSU8pICs9IHZpcnRpb19jcnlwdG8ubwo+ PiDCoCB2aXJ0aW9fY3J5cHRvLW9ianMgOj0gXAo+PiDCoMKgwqDCoMKgIHZpcnRpb19jcnlwdG9f c2tjaXBoZXJfYWxncy5vIFwKPj4gwqDCoMKgwqDCoCB2aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2Fs Z3MubyBcCj4+ICvCoMKgwqAgdmlydGlvX2NyeXB0b19jb21tb24ubyBcCj4+IMKgwqDCoMKgwqAg dmlydGlvX2NyeXB0b19tZ3IubyBcCj4+IMKgwqDCoMKgwqAgdmlydGlvX2NyeXB0b19jb3JlLm8K Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2FrY2lw aGVyX2FsZ3MuYyAKPj4gYi9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0b19ha2Np cGhlcl9hbGdzLmMKPj4gaW5kZXggZjNlYzk0MjAyMTVlLi45NTYxYmMyZGY2MmIgMTAwNjQ0Cj4+ IC0tLSBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2FsZ3Mu Ywo+PiArKysgYi9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0b19ha2NpcGhlcl9h bGdzLmMKPj4gQEAgLTEwMiw4ICsxMDIsOCBAQCBzdGF0aWMgaW50IAo+PiB2aXJ0aW9fY3J5cHRv X2FsZ19ha2NpcGhlcl9pbml0X3Nlc3Npb24oc3RydWN0IHZpcnRpb19jcnlwdG9fYWtjaXBoZXIK Pj4gwqAgewo+PiDCoMKgwqDCoMKgIHN0cnVjdCBzY2F0dGVybGlzdCBvdXRoZHJfc2csIGtleV9z ZywgaW5oZHJfc2csICpzZ3NbM107Cj4+IMKgwqDCoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG8g KnZjcnlwdG8gPSBjdHgtPnZjcnlwdG87Cj4+ICvCoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG9f Y3RybF9yZXF1ZXN0ICp2Y19jdHJsX3JlcTsKPj4gwqDCoMKgwqDCoCB1aW50OF90ICpwa2V5Owo+ PiAtwqDCoMKgIHVuc2lnbmVkIGludCBpbmxlbjsKPj4gwqDCoMKgwqDCoCBpbnQgZXJyOwo+PiDC oMKgwqDCoMKgIHVuc2lnbmVkIGludCBudW1fb3V0ID0gMCwgbnVtX2luID0gMDsKPj4gQEAgLTEx MSw5OCArMTExLDkxIEBAIHN0YXRpYyBpbnQgCj4+IHZpcnRpb19jcnlwdG9fYWxnX2FrY2lwaGVy X2luaXRfc2Vzc2lvbihzdHJ1Y3QgdmlydGlvX2NyeXB0b19ha2NpcGhlcgo+PiDCoMKgwqDCoMKg IGlmICghcGtleSkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiAtRU5PTUVNOwo+PiAtwqDC oMKgIHNwaW5fbG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPj4gLcKgwqDCoCBtZW1jcHkoJnZj cnlwdG8tPmN0cmwuaGVhZGVyLCBoZWFkZXIsIHNpemVvZih2Y3J5cHRvLT5jdHJsLmhlYWRlcikp Owo+PiAtwqDCoMKgIG1lbWNweSgmdmNyeXB0by0+Y3RybC51LCBwYXJhLCBzaXplb2YodmNyeXB0 by0+Y3RybC51KSk7Cj4+IC3CoMKgwqAgdmNyeXB0by0+aW5wdXQuc3RhdHVzID0gY3B1X3RvX2xl MzIoVklSVElPX0NSWVBUT19FUlIpOwo+PiArwqDCoMKgIHZjX2N0cmxfcmVxID0ga3phbGxvYyhz aXplb2YoKnZjX2N0cmxfcmVxKSwgR0ZQX0tFUk5FTCk7Cj4+ICvCoMKgwqAgaWYgKCF2Y19jdHJs X3JlcSkgewo+PiArwqDCoMKgwqDCoMKgwqAgZXJyID0gLUVOT01FTTsKPj4gK8KgwqDCoMKgwqDC oMKgIGdvdG8gb3V0Owo+PiArwqDCoMKgIH0KPj4gLcKgwqDCoCBzZ19pbml0X29uZSgmb3V0aGRy X3NnLCAmdmNyeXB0by0+Y3RybCwgc2l6ZW9mKHZjcnlwdG8tPmN0cmwpKTsKPj4gK8KgwqDCoCBt ZW1jcHkoJnZjX2N0cmxfcmVxLT5jdHJsLmhlYWRlciwgaGVhZGVyLCAKPj4gc2l6ZW9mKHZjX2N0 cmxfcmVxLT5jdHJsLmhlYWRlcikpOwo+PiArwqDCoMKgIG1lbWNweSgmdmNfY3RybF9yZXEtPmN0 cmwudSwgcGFyYSwgc2l6ZW9mKHZjX2N0cmxfcmVxLT5jdHJsLnUpKTsKPj4gK8KgwqDCoCBzZ19p bml0X29uZSgmb3V0aGRyX3NnLCAmdmNfY3RybF9yZXEtPmN0cmwsIAo+PiBzaXplb2YodmNfY3Ry bF9yZXEtPmN0cmwpKTsKPj4gwqDCoMKgwqDCoCBzZ3NbbnVtX291dCsrXSA9ICZvdXRoZHJfc2c7 Cj4+IMKgwqDCoMKgwqAgc2dfaW5pdF9vbmUoJmtleV9zZywgcGtleSwga2V5bGVuKTsKPj4gwqDC oMKgwqDCoCBzZ3NbbnVtX291dCsrXSA9ICZrZXlfc2c7Cj4+IC3CoMKgwqAgc2dfaW5pdF9vbmUo JmluaGRyX3NnLCAmdmNyeXB0by0+aW5wdXQsIHNpemVvZih2Y3J5cHRvLT5pbnB1dCkpOwo+PiAr wqDCoMKgIHZjX2N0cmxfcmVxLT5pbnB1dC5zdGF0dXMgPSBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZ UFRPX0VSUik7Cj4gCj4gCj4gTml0OiBpZiB0aGVyZSdzIG5vIHNwZWNpYWwgcmVhc29uLCBsZXQn cyBtb3ZlIHRoaXMgYWZ0ZXIgdGhlIGFib3ZlIAo+IG1lbWNweXMgYXMgd2hhdCdzIGRvbmUgcHJl dmlvdXNseS4KPiAKPiAKPj4gK8KgwqDCoCBzZ19pbml0X29uZSgmaW5oZHJfc2csICZ2Y19jdHJs X3JlcS0+aW5wdXQsIAo+PiBzaXplb2YodmNfY3RybF9yZXEtPmlucHV0KSk7Cj4+IMKgwqDCoMKg wqAgc2dzW251bV9vdXQgKyBudW1faW4rK10gPSAmaW5oZHJfc2c7Cj4+IC3CoMKgwqAgZXJyID0g dmlydHF1ZXVlX2FkZF9zZ3ModmNyeXB0by0+Y3RybF92cSwgc2dzLCBudW1fb3V0LCBudW1faW4s IAo+PiB2Y3J5cHRvLCBHRlBfQVRPTUlDKTsKPj4gK8KgwqDCoCBlcnIgPSB2aXJ0aW9fY3J5cHRv X2N0cmxfdnFfcmVxdWVzdCh2Y3J5cHRvLCBzZ3MsIG51bV9vdXQsIAo+PiBudW1faW4sIHZjX2N0 cmxfcmVxKTsKPiAKPiAKPiBJJ2Qgc3BsaXQgdGhpcyBpbnRvIGEgc2VwYXJhdGUgcGF0Y2guCj4g CgpPSyEKPiAKPj4gwqDCoMKgwqDCoCBpZiAoZXJyIDwgMCkKPj4gwqDCoMKgwqDCoMKgwqDCoMKg IGdvdG8gb3V0Owo+PiAtwqDCoMKgIHZpcnRxdWV1ZV9raWNrKHZjcnlwdG8tPmN0cmxfdnEpOwo+ PiAtwqDCoMKgIHdoaWxlICghdmlydHF1ZXVlX2dldF9idWYodmNyeXB0by0+Y3RybF92cSwgJmlu bGVuKSAmJgo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqAgIXZpcnRxdWV1ZV9pc19icm9rZW4odmNy eXB0by0+Y3RybF92cSkpCj4+IC3CoMKgwqDCoMKgwqDCoCBjcHVfcmVsYXgoKTsKPj4gLQo+PiAt wqDCoMKgIGlmIChsZTMyX3RvX2NwdSh2Y3J5cHRvLT5pbnB1dC5zdGF0dXMpICE9IFZJUlRJT19D UllQVE9fT0spIHsKPj4gK8KgwqDCoCBpZiAobGUzMl90b19jcHUodmNfY3RybF9yZXEtPmlucHV0 LnN0YXR1cykgIT0gVklSVElPX0NSWVBUT19PSykgewo+PiArwqDCoMKgwqDCoMKgwqAgcHJfZXJy KCJ2aXJ0aW9fY3J5cHRvOiBDcmVhdGUgc2Vzc2lvbiBmYWlsZWQgc3RhdHVzOiAldVxuIiwKPj4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbGUzMl90b19jcHUodmNfY3RybF9yZXEtPmlucHV0LnN0 YXR1cykpOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgZXJyID0gLUVJTlZBTDsKPj4gwqDCoMKgwqDC oMKgwqDCoMKgIGdvdG8gb3V0Owo+PiDCoMKgwqDCoMKgIH0KPiAKPiAKPiBEbyB3ZSBuZWVkIGEg d2FybmluZyBmb3IgLUVOT01FTT8KPiAKCk1lbW9yeShlc3BlY2lhbGx5IHNtYWxsIHNpemUpIGFs bG9jYXRpb24gaXMgdW5saWtlbHkgY2FzZSwgSSBhbHNvIGNoZWNrIAp0aGUgdmlydGlvX25ldCBh bmQgdmlydGlvX2JsaywgYm90aCBoYW5kbGVzIC1FTk9NRU0gb25seSB3aXRob3V0IGVycm9yIApy ZXBvcnRpbmcuCgo+IAo+PiAtwqDCoMKgIGN0eC0+c2Vzc2lvbl9pZCA9IGxlNjRfdG9fY3B1KHZj cnlwdG8tPmlucHV0LnNlc3Npb25faWQpOwo+PiArwqDCoMKgIGN0eC0+c2Vzc2lvbl9pZCA9IGxl NjRfdG9fY3B1KHZjX2N0cmxfcmVxLT5pbnB1dC5zZXNzaW9uX2lkKTsKPj4gwqDCoMKgwqDCoCBj dHgtPnNlc3Npb25fdmFsaWQgPSB0cnVlOwo+PiDCoMKgwqDCoMKgIGVyciA9IDA7Cj4+IMKgIG91 dDoKPj4gLcKgwqDCoCBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPj4gK8KgwqDC oCBrZnJlZSh2Y19jdHJsX3JlcSk7Cj4+IMKgwqDCoMKgwqAga2ZyZWVfc2Vuc2l0aXZlKHBrZXkp Owo+PiAtwqDCoMKgIGlmIChlcnIgPCAwKQo+PiAtwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCJ2aXJ0 aW9fY3J5cHRvOiBDcmVhdGUgc2Vzc2lvbiBmYWlsZWQgc3RhdHVzOiAldVxuIiwKPj4gLcKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgbGUzMl90b19jcHUodmNyeXB0by0+aW5wdXQuc3RhdHVzKSk7Cj4+ IC0KPj4gwqDCoMKgwqDCoCByZXR1cm4gZXJyOwo+PiDCoCB9Cj4+IMKgIHN0YXRpYyBpbnQgdmly dGlvX2NyeXB0b19hbGdfYWtjaXBoZXJfY2xvc2Vfc2Vzc2lvbihzdHJ1Y3QgCj4+IHZpcnRpb19j cnlwdG9fYWtjaXBoZXJfY3R4ICpjdHgpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3Qgc2Nh dHRlcmxpc3Qgb3V0aGRyX3NnLCBpbmhkcl9zZywgKnNnc1syXTsKPj4gK8KgwqDCoCBzdHJ1Y3Qg dmlydGlvX2NyeXB0b19jdHJsX3JlcXVlc3QgKnZjX2N0cmxfcmVxOwo+PiDCoMKgwqDCoMKgIHN0 cnVjdCB2aXJ0aW9fY3J5cHRvX2Rlc3Ryb3lfc2Vzc2lvbl9yZXEgKmRlc3Ryb3lfc2Vzc2lvbjsK Pj4gwqDCoMKgwqDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0byAqdmNyeXB0byA9IGN0eC0+dmNyeXB0 bzsKPj4gLcKgwqDCoCB1bnNpZ25lZCBpbnQgbnVtX291dCA9IDAsIG51bV9pbiA9IDAsIGlubGVu Owo+PiArwqDCoMKgIHVuc2lnbmVkIGludCBudW1fb3V0ID0gMCwgbnVtX2luID0gMDsKPj4gwqDC oMKgwqDCoCBpbnQgZXJyOwo+PiAtwqDCoMKgIHNwaW5fbG9jaygmdmNyeXB0by0+Y3RybF9sb2Nr KTsKPj4gLcKgwqDCoCBpZiAoIWN0eC0+c2Vzc2lvbl92YWxpZCkgewo+PiAtwqDCoMKgwqDCoMKg wqAgZXJyID0gMDsKPj4gLcKgwqDCoMKgwqDCoMKgIGdvdG8gb3V0Owo+PiAtwqDCoMKgIH0KPj4g LcKgwqDCoCB2Y3J5cHRvLT5jdHJsX3N0YXR1cy5zdGF0dXMgPSBWSVJUSU9fQ1JZUFRPX0VSUjsK Pj4gLcKgwqDCoCB2Y3J5cHRvLT5jdHJsLmhlYWRlci5vcGNvZGUgPSAKPj4gY3B1X3RvX2xlMzIo VklSVElPX0NSWVBUT19BS0NJUEhFUl9ERVNUUk9ZX1NFU1NJT04pOwo+PiAtwqDCoMKgIHZjcnlw dG8tPmN0cmwuaGVhZGVyLnF1ZXVlX2lkID0gMDsKPj4gK8KgwqDCoCBpZiAoIWN0eC0+c2Vzc2lv bl92YWxpZCkKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiAwOwo+PiAtwqDCoMKgIGRlc3Ryb3lf c2Vzc2lvbiA9ICZ2Y3J5cHRvLT5jdHJsLnUuZGVzdHJveV9zZXNzaW9uOwo+PiArwqDCoMKgIHZj X2N0cmxfcmVxID0ga3phbGxvYyhzaXplb2YoKnZjX2N0cmxfcmVxKSwgR0ZQX0tFUk5FTCk7Cj4+ ICvCoMKgwqAgaWYgKCF2Y19jdHJsX3JlcSkKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiAtRU5P TUVNOwo+PiArCj4+ICvCoMKgwqAgdmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyLm9wY29kZSA9IAo+ PiBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZUFRPX0FLQ0lQSEVSX0RFU1RST1lfU0VTU0lPTik7Cj4+ ICvCoMKgwqAgdmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyLnF1ZXVlX2lkID0gMDsKPj4gKwo+PiAr wqDCoMKgIGRlc3Ryb3lfc2Vzc2lvbiA9ICZ2Y19jdHJsX3JlcS0+Y3RybC51LmRlc3Ryb3lfc2Vz c2lvbjsKPj4gwqDCoMKgwqDCoCBkZXN0cm95X3Nlc3Npb24tPnNlc3Npb25faWQgPSBjcHVfdG9f bGU2NChjdHgtPnNlc3Npb25faWQpOwo+PiAtwqDCoMKgIHNnX2luaXRfb25lKCZvdXRoZHJfc2cs ICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNyeXB0by0+Y3RybCkpOwo+PiArwqDCoMKgIHNnX2lu aXRfb25lKCZvdXRoZHJfc2csICZ2Y19jdHJsX3JlcS0+Y3RybCwgCj4+IHNpemVvZih2Y19jdHJs X3JlcS0+Y3RybCkpOwo+PiDCoMKgwqDCoMKgIHNnc1tudW1fb3V0KytdID0gJm91dGhkcl9zZzsK Pj4gLcKgwqDCoCBzZ19pbml0X29uZSgmaW5oZHJfc2csICZ2Y3J5cHRvLT5jdHJsX3N0YXR1cy5z dGF0dXMsIAo+PiBzaXplb2YodmNyeXB0by0+Y3RybF9zdGF0dXMuc3RhdHVzKSk7Cj4+ICvCoMKg wqAgdmNfY3RybF9yZXEtPmN0cmxfc3RhdHVzLnN0YXR1cyA9IFZJUlRJT19DUllQVE9fRVJSOwo+ IAo+IAo+IElmIG5vIHNwZWNpYWwgcmVhc29uLCBsZXQncyBtb3ZlIHRoaXMgYWJvdmU6Cj4gCj4g dmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyLm9wY29kZSA9IAo+IGNwdV90b19sZTMyKFZJUlRJT19D UllQVE9fQUtDSVBIRVJfREVTVFJPWV9TRVNTSU9OKTsKPiAKCk9LIQo+IAo+PiArwqDCoMKgIHNn X2luaXRfb25lKCZpbmhkcl9zZywgJnZjX2N0cmxfcmVxLT5jdHJsX3N0YXR1cy5zdGF0dXMsCj4+ ICvCoMKgwqDCoMKgwqDCoCBzaXplb2YodmNfY3RybF9yZXEtPmN0cmxfc3RhdHVzLnN0YXR1cykp Owo+PiDCoMKgwqDCoMKgIHNnc1tudW1fb3V0ICsgbnVtX2luKytdID0gJmluaGRyX3NnOwo+PiAt wqDCoMKgIGVyciA9IHZpcnRxdWV1ZV9hZGRfc2dzKHZjcnlwdG8tPmN0cmxfdnEsIHNncywgbnVt X291dCwgbnVtX2luLCAKPj4gdmNyeXB0bywgR0ZQX0FUT01JQyk7Cj4+ICvCoMKgwqAgZXJyID0g dmlydGlvX2NyeXB0b19jdHJsX3ZxX3JlcXVlc3QodmNyeXB0bywgc2dzLCBudW1fb3V0LCAKPj4g bnVtX2luLCB2Y19jdHJsX3JlcSk7Cj4+IMKgwqDCoMKgwqAgaWYgKGVyciA8IDApCj4+IMKgwqDC oMKgwqDCoMKgwqDCoCBnb3RvIG91dDsKPj4gLcKgwqDCoCB2aXJ0cXVldWVfa2ljayh2Y3J5cHRv LT5jdHJsX3ZxKTsKPj4gLcKgwqDCoCB3aGlsZSAoIXZpcnRxdWV1ZV9nZXRfYnVmKHZjcnlwdG8t PmN0cmxfdnEsICZpbmxlbikgJiYKPj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgICF2aXJ0cXVldWVf aXNfYnJva2VuKHZjcnlwdG8tPmN0cmxfdnEpKQo+PiAtwqDCoMKgwqDCoMKgwqAgY3B1X3JlbGF4 KCk7Cj4+IC0KPj4gLcKgwqDCoCBpZiAodmNyeXB0by0+Y3RybF9zdGF0dXMuc3RhdHVzICE9IFZJ UlRJT19DUllQVE9fT0spIHsKPj4gK8KgwqDCoCBpZiAodmNfY3RybF9yZXEtPmN0cmxfc3RhdHVz LnN0YXR1cyAhPSBWSVJUSU9fQ1JZUFRPX09LKSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBlcnIg PSAtRUlOVkFMOwo+PiArwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCJ2aXJ0aW9fY3J5cHRvOiBDbG9z ZSBzZXNzaW9uIGZhaWxlZCBzdGF0dXM6ICV1LCAKPj4gc2Vzc2lvbl9pZDogMHglbGx4XG4iLAo+ PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2Y19jdHJsX3JlcS0+Y3RybF9zdGF0dXMuc3RhdHVz LCAKPj4gZGVzdHJveV9zZXNzaW9uLT5zZXNzaW9uX2lkKTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKg IGdvdG8gb3V0Owo+PiDCoMKgwqDCoMKgIH0KPj4gwqDCoMKgwqDCoCBlcnIgPSAwOwo+PiDCoMKg wqDCoMKgIGN0eC0+c2Vzc2lvbl92YWxpZCA9IGZhbHNlOwo+PiAtCj4+IMKgIG91dDoKPj4gLcKg wqDCoCBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPj4gLcKgwqDCoCBpZiAoZXJy IDwgMCkgewo+PiAtwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCJ2aXJ0aW9fY3J5cHRvOiBDbG9zZSBz ZXNzaW9uIGZhaWxlZCBzdGF0dXM6ICV1LCAKPj4gc2Vzc2lvbl9pZDogMHglbGx4XG4iLAo+PiAt wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2Y3J5cHRvLT5jdHJsX3N0YXR1cy5zdGF0dXMsIGRlc3Ry b3lfc2Vzc2lvbi0+c2Vzc2lvbl9pZCk7Cj4+IC3CoMKgwqAgfQo+PiArwqDCoMKgIGtmcmVlKHZj X2N0cmxfcmVxKTsKPj4gwqDCoMKgwqDCoCByZXR1cm4gZXJyOwo+PiDCoCB9Cj4+IEBAIC0yMTAs MTQgKzIwMywxMSBAQCBzdGF0aWMgaW50IAo+PiB2aXJ0aW9fY3J5cHRvX2FsZ19ha2NpcGhlcl9j bG9zZV9zZXNzaW9uKHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2FrY2lwaGUKPj4gwqAgc3RhdGljIGlu dCBfX3ZpcnRpb19jcnlwdG9fYWtjaXBoZXJfZG9fcmVxKHN0cnVjdCAKPj4gdmlydGlvX2NyeXB0 b19ha2NpcGhlcl9yZXF1ZXN0ICp2Y19ha2NpcGhlcl9yZXEsCj4+IMKgwqDCoMKgwqDCoMKgwqDC oCBzdHJ1Y3QgYWtjaXBoZXJfcmVxdWVzdCAqcmVxLCBzdHJ1Y3QgZGF0YV9xdWV1ZSAqZGF0YV92 cSkKPj4gwqAgewo+PiAtwqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2N0eCAq Y3R4ID0gCj4+IHZjX2FrY2lwaGVyX3JlcS0+YWtjaXBoZXJfY3R4Owo+PiDCoMKgwqDCoMKgIHN0 cnVjdCB2aXJ0aW9fY3J5cHRvX3JlcXVlc3QgKnZjX3JlcSA9ICZ2Y19ha2NpcGhlcl9yZXEtPmJh c2U7Cj4+IC3CoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG8gKnZjcnlwdG8gPSBjdHgtPnZjcnlw dG87Cj4+IMKgwqDCoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG9fb3BfZGF0YV9yZXEgKnJlcV9k YXRhID0gdmNfcmVxLT5yZXFfZGF0YTsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3Qgc2NhdHRlcmxpc3Qg KnNnc1s0XSwgb3V0aGRyX3NnLCBpbmhkcl9zZywgc3JjZGF0YV9zZywgCj4+IGRzdGRhdGFfc2c7 Cj4+IMKgwqDCoMKgwqAgdm9pZCAqc3JjX2J1ZiA9IE5VTEwsICpkc3RfYnVmID0gTlVMTDsKPj4g wqDCoMKgwqDCoCB1bnNpZ25lZCBpbnQgbnVtX291dCA9IDAsIG51bV9pbiA9IDA7Cj4+IC3CoMKg wqAgaW50IG5vZGUgPSBkZXZfdG9fbm9kZSgmdmNyeXB0by0+dmRldi0+ZGV2KTsKPj4gwqDCoMKg wqDCoCB1bnNpZ25lZCBsb25nIGZsYWdzOwo+PiDCoMKgwqDCoMKgIGludCByZXQgPSAtRU5PTUVN Owo+PiDCoMKgwqDCoMKgIGJvb2wgdmVyaWZ5ID0gdmNfYWtjaXBoZXJfcmVxLT5vcGNvZGUgPT0g Cj4+IFZJUlRJT19DUllQVE9fQUtDSVBIRVJfVkVSSUZZOwo+PiBAQCAtMjI4LDcgKzIxOCw3IEBA IHN0YXRpYyBpbnQgX192aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2RvX3JlcShzdHJ1Y3QgCj4+IHZp cnRpb19jcnlwdG9fYWtjaXBoZXJfcmVxdWVzdAo+PiDCoMKgwqDCoMKgIHNnc1tudW1fb3V0Kytd ID0gJm91dGhkcl9zZzsKPj4gwqDCoMKgwqDCoCAvKiBzcmMgZGF0YSAqLwo+PiAtwqDCoMKgIHNy Y19idWYgPSBrY2FsbG9jX25vZGUoc3JjX2xlbiwgMSwgR0ZQX0tFUk5FTCwgbm9kZSk7Cj4+ICvC oMKgwqAgc3JjX2J1ZiA9IGtjYWxsb2Moc3JjX2xlbiwgMSwgR0ZQX0tFUk5FTCk7Cj4gCj4gCj4g VGhpcyBzZWVtcyBub3QgYSByZWxldmFudCBjaGFuZ2UuIElmIGl0IGlzIGEgbXVzdCB3ZSBuZWVk IHVzZSBhIHNlcGFyYXRlIAo+IGZvciB0aGlzIGFuZCBkZXNjcmliZSB0aGUgcmF0aW9uYWxlLgo+ IAo+IAo+PiDCoMKgwqDCoMKgIGlmICghc3JjX2J1ZikKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIGdv dG8gZXJyOwo+PiBAQCAtMjQzLDcgKzIzMyw3IEBAIHN0YXRpYyBpbnQgX192aXJ0aW9fY3J5cHRv X2FrY2lwaGVyX2RvX3JlcShzdHJ1Y3QgCj4+IHZpcnRpb19jcnlwdG9fYWtjaXBoZXJfcmVxdWVz dAo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgc2dzW251bV9vdXQrK10gPSAmc3JjZGF0YV9zZzsKPj4g wqDCoMKgwqDCoMKgwqDCoMKgIC8qIGRzdCBkYXRhICovCj4+IC3CoMKgwqDCoMKgwqDCoCBkc3Rf YnVmID0ga2NhbGxvY19ub2RlKHJlcS0+ZHN0X2xlbiwgMSwgR0ZQX0tFUk5FTCwgbm9kZSk7Cj4+ ICvCoMKgwqDCoMKgwqDCoCBkc3RfYnVmID0ga2NhbGxvYyhyZXEtPmRzdF9sZW4sIDEsIEdGUF9L RVJORUwpOwo+IAo+IAo+IEFuZCB0aGlzLgo+IAo+IAo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgaWYg KCFkc3RfYnVmKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIGVycjsKPj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1vbi5jIAo+ PiBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1vbi5jCj4+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAwMDAwMC4uZTY1MTI1YTc0ZGIyCj4+IC0t LSAvZGV2L251bGwKPj4gKysrIGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9f Y29tbW9uLmMKPj4gQEAgLTAsMCArMSwzOSBAQAo+PiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAtb3ItbGF0ZXIKPj4gKy8qIENvbW1vbiBmdW5jdGlvbnMgYW5kIGhlbHBlcnMK Pj4gKyAqCj4+ICsgKiBBdXRob3JzOiB6aGVud2VpIHBpIDxwaXpoZW53ZWlAYnl0ZWRhbmNlLmNv bT4KPj4gKyAqCj4+ICsgKiBDb3B5cmlnaHQgMjAyMiBCeXRlZGFuY2UgQ08uLCBMVEQuCj4+ICsg Ki8KPj4gKwo+PiArI2luY2x1ZGUgInZpcnRpb19jcnlwdG9fY29tbW9uLmgiCj4+ICsKPj4gK2lu dCB2aXJ0aW9fY3J5cHRvX2N0cmxfdnFfcmVxdWVzdChzdHJ1Y3QgdmlydGlvX2NyeXB0byAqdmNy eXB0bywgCj4+IHN0cnVjdCBzY2F0dGVybGlzdCAqc2dzW10sCj4+ICvCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHVuc2lnbmVkIGludCBvdXRfc2dzLCB1bnNpZ25lZCBpbnQgaW5f c2dzLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgdmlydGlv X2NyeXB0b19jdHJsX3JlcXVlc3QgKnZjX2N0cmxfcmVxKQo+PiArewo+PiArwqDCoMKgIGludCBl cnI7Cj4+ICvCoMKgwqAgdW5zaWduZWQgaW50IGlubGVuOwo+PiArwqDCoMKgIHVuc2lnbmVkIGxv bmcgZmxhZ3M7Cj4+ICsKPj4gK8KgwqDCoCBzcGluX2xvY2tfaXJxc2F2ZSgmdmNyeXB0by0+Y3Ry bF9sb2NrLCBmbGFncyk7Cj4+ICvCoMKgwqAgZXJyID0gdmlydHF1ZXVlX2FkZF9zZ3ModmNyeXB0 by0+Y3RybF92cSwgc2dzLCBvdXRfc2dzLCBpbl9zZ3MsIAo+PiB2Y19jdHJsX3JlcSwgR0ZQX0FU T01JQyk7Cj4+ICvCoMKgwqAgaWYgKGVyciA8IDApIHsKPj4gK8KgwqDCoMKgwqDCoMKgIHNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJnZjcnlwdG8tPmN0cmxfbG9jaywgZmxhZ3MpOwo+PiArwqDCoMKg wqDCoMKgwqAgcmV0dXJuIGVycjsKPj4gK8KgwqDCoCB9Cj4+ICsKPj4gK8KgwqDCoCB2aXJ0cXVl dWVfa2ljayh2Y3J5cHRvLT5jdHJsX3ZxKTsKPj4gKwo+PiArwqDCoMKgIC8qCj4+ICvCoMKgwqDC oCAqIFRyYXBwaW5nIGludG8gdGhlIGh5cGVydmlzb3IsIHNvIHRoZSByZXF1ZXN0IHNob3VsZCBi ZQo+PiArwqDCoMKgwqAgKiBoYW5kbGVkIGltbWVkaWF0ZWx5Lgo+PiArwqDCoMKgwqAgKi8KPj4g K8KgwqDCoCB3aGlsZSAoIXZpcnRxdWV1ZV9nZXRfYnVmKHZjcnlwdG8tPmN0cmxfdnEsICZpbmxl bikgJiYKPj4gK8KgwqDCoMKgwqDCoMKgICF2aXJ0cXVldWVfaXNfYnJva2VuKHZjcnlwdG8tPmN0 cmxfdnEpKQo+PiArwqDCoMKgwqDCoMKgwqAgY3B1X3JlbGF4KCk7Cj4+ICsKPj4gK8KgwqDCoCBz cGluX3VubG9ja19pcnFyZXN0b3JlKCZ2Y3J5cHRvLT5jdHJsX2xvY2ssIGZsYWdzKTsKPj4gKwo+ PiArwqDCoMKgIHJldHVybiAwOwo+PiArfQo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9jcnlwdG8v dmlydGlvL3ZpcnRpb19jcnlwdG9fY29tbW9uLmggCj4+IGIvZHJpdmVycy9jcnlwdG8vdmlydGlv L3ZpcnRpb19jcnlwdG9fY29tbW9uLmgKPj4gaW5kZXggZTY5M2Q0ZWU4M2E2Li5kMmEyMGZlNmUx M2UgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2Nv bW1vbi5oCj4+ICsrKyBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1v bi5oCj4+IEBAIC0xMyw2ICsxMyw3IEBACj4+IMKgICNpbmNsdWRlIDxjcnlwdG8vYWVhZC5oPgo+ PiDCoCAjaW5jbHVkZSA8Y3J5cHRvL2Flcy5oPgo+PiDCoCAjaW5jbHVkZSA8Y3J5cHRvL2VuZ2lu ZS5oPgo+PiArI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX2NyeXB0by5oPgo+PiDCoCAvKiBJ bnRlcm5hbCByZXByZXNlbnRhdGlvbiBvZiBhIGRhdGEgdmlydHF1ZXVlICovCj4+IEBAIC02NSwx MSArNjYsNiBAQCBzdHJ1Y3QgdmlydGlvX2NyeXB0byB7Cj4+IMKgwqDCoMKgwqAgLyogTWF4aW11 bSBzaXplIG9mIHBlciByZXF1ZXN0ICovCj4+IMKgwqDCoMKgwqAgdTY0IG1heF9zaXplOwo+PiAt wqDCoMKgIC8qIENvbnRyb2wgVlEgYnVmZmVyczogcHJvdGVjdGVkIGJ5IHRoZSBjdHJsX2xvY2sg Ki8KPj4gLcKgwqDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0b19vcF9jdHJsX3JlcSBjdHJsOwo+PiAt wqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX3Nlc3Npb25faW5wdXQgaW5wdXQ7Cj4+IC3CoMKg wqAgc3RydWN0IHZpcnRpb19jcnlwdG9faW5oZHIgY3RybF9zdGF0dXM7Cj4+IC0KPj4gwqDCoMKg wqDCoCB1bnNpZ25lZCBsb25nIHN0YXR1czsKPj4gwqDCoMKgwqDCoCBhdG9taWNfdCByZWZfY291 bnQ7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGxpc3RfaGVhZCBsaXN0Owo+PiBAQCAtODUsNiArODEs MTYgQEAgc3RydWN0IHZpcnRpb19jcnlwdG9fc3ltX3Nlc3Npb25faW5mbyB7Cj4+IMKgwqDCoMKg wqAgX191NjQgc2Vzc2lvbl9pZDsKPj4gwqAgfTsKPj4gKy8qCj4+ICsgKiBOb3RlOiB0aGVyZSBh cmUgcGFkZGluZyBmaWVsZHMgaW4gcmVxdWVzdCwgY2xlYXIgdGhlbSB0byB6ZXJvIAo+PiBiZWZv cmUgc2VuZGluZyB0byBob3N0LAo+PiArICogRXgsIHZpcnRpb19jcnlwdG9fY3RybF9yZXF1ZXN0 OjpjdHJsOjp1OjpkZXN0cm95X3Nlc3Npb246OnBhZGRpbmdbNDhdCj4+ICsgKi8KPj4gK3N0cnVj dCB2aXJ0aW9fY3J5cHRvX2N0cmxfcmVxdWVzdCB7Cj4+ICvCoMKgwqAgc3RydWN0IHZpcnRpb19j cnlwdG9fb3BfY3RybF9yZXEgY3RybDsKPj4gK8KgwqDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0b19z ZXNzaW9uX2lucHV0IGlucHV0Owo+PiArwqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2luaGRy IGN0cmxfc3RhdHVzOwo+PiArfTsKPj4gKwo+PiDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0b19yZXF1 ZXN0Owo+PiDCoCB0eXBlZGVmIHZvaWQgKCp2aXJ0aW9fY3J5cHRvX2RhdGFfY2FsbGJhY2spCj4+ IMKgwqDCoMKgwqDCoMKgwqDCoCAoc3RydWN0IHZpcnRpb19jcnlwdG9fcmVxdWVzdCAqdmNfcmVx LCBpbnQgbGVuKTsKPj4gQEAgLTEzNSw0ICsxNDEsNyBAQCB2b2lkIHZpcnRpb19jcnlwdG9fc2tj aXBoZXJfYWxnc191bnJlZ2lzdGVyKHN0cnVjdCAKPj4gdmlydGlvX2NyeXB0byAqdmNyeXB0byk7 Cj4+IMKgIGludCB2aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2FsZ3NfcmVnaXN0ZXIoc3RydWN0IHZp cnRpb19jcnlwdG8gCj4+ICp2Y3J5cHRvKTsKPj4gwqAgdm9pZCB2aXJ0aW9fY3J5cHRvX2FrY2lw aGVyX2FsZ3NfdW5yZWdpc3RlcihzdHJ1Y3QgdmlydGlvX2NyeXB0byAKPj4gKnZjcnlwdG8pOwo+ PiAraW50IHZpcnRpb19jcnlwdG9fY3RybF92cV9yZXF1ZXN0KHN0cnVjdCB2aXJ0aW9fY3J5cHRv ICp2Y3J5cHRvLCAKPj4gc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ3NbXSwKPj4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdW5zaWduZWQgaW50IG91dF9zZ3MsIHVuc2lnbmVkIGlu dCBpbl9zZ3MsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCB2 aXJ0aW9fY3J5cHRvX2N0cmxfcmVxdWVzdCAqdmNfY3RybF9yZXEpOwo+PiDCoCAjZW5kaWYgLyog X1ZJUlRJT19DUllQVE9fQ09NTU9OX0ggKi8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRv L3ZpcnRpby92aXJ0aW9fY3J5cHRvX3NrY2lwaGVyX2FsZ3MuYyAKPj4gYi9kcml2ZXJzL2NyeXB0 by92aXJ0aW8vdmlydGlvX2NyeXB0b19za2NpcGhlcl9hbGdzLmMKPj4gaW5kZXggYTYxOGM0NmE1 MmI4Li5mZWYzNTVmZjQ2MWMgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92 aXJ0aW9fY3J5cHRvX3NrY2lwaGVyX2FsZ3MuYwo+PiArKysgYi9kcml2ZXJzL2NyeXB0by92aXJ0 aW8vdmlydGlvX2NyeXB0b19za2NpcGhlcl9hbGdzLmMKPj4gQEAgLTExOCwxMSArMTE4LDEzIEBA IHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfaW5pdF9zZXNzaW9uKAo+PiDC oMKgwqDCoMKgwqDCoMKgwqAgaW50IGVuY3J5cHQpCj4+IMKgIHsKPj4gwqDCoMKgwqDCoCBzdHJ1 Y3Qgc2NhdHRlcmxpc3Qgb3V0aGRyLCBrZXlfc2csIGluaGRyLCAqc2dzWzNdOwo+PiAtwqDCoMKg IHVuc2lnbmVkIGludCB0bXA7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG8gKnZj cnlwdG8gPSBjdHgtPnZjcnlwdG87Cj4gCj4gCj4gQ2FuIHdlIHNpbXBseSByZW5hbWUgdGhpcyB0 byB2aXJ0Y3J5cHRvIGFuZCB0aGVuIHdlIGNhbiB1c2UgdGhlIG5hbWUgCj4gInZjcnlwdG8iIGZv ciB2aXJ0aW9fY3J5cHRvX2N0cmxfcmVxdWVzdCB0aGVuIHdlIHNhdmUgdG9ucyBsb3QgY2hhbmdl cz8KPiAKPiBJdCBzaW1wbGlmeSB0aGUgbGlmZSBvZiByZXZpZXdlcnMgYW5kIGJhY2twb3J0aW5n Lgo+IAo+IFRoYW5rcwo+IAoKVGhpcyBzZXJpZXMgZm9jdXNlcyBvbiBwZXJmb3JtYW5jZSBpbXBy b3ZtZW50LCBhbmQga2VlcHMgdGhlIHN0eWxlIHdpdGggCnRoZSBvcmlnbmFsIHN0eWxlLiBXaGF0 IGFib3V0IGZpeGluZyB0aGlzIGluIGFub3RoZXIgc2VyaWVzPyAoSWYgc28sIApJJ2xsIGZpeCB0 aGlzIGxhdGVyKQo+IAo+PiDCoMKgwqDCoMKgIGludCBvcCA9IGVuY3J5cHQgPyBWSVJUSU9fQ1JZ UFRPX09QX0VOQ1JZUFQgOiAKPj4gVklSVElPX0NSWVBUT19PUF9ERUNSWVBUOwo+PiDCoMKgwqDC oMKgIGludCBlcnI7Cj4+IMKgwqDCoMKgwqAgdW5zaWduZWQgaW50IG51bV9vdXQgPSAwLCBudW1f aW4gPSAwOwo+PiArwqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2N0cmxfcmVxdWVzdCAqdmNf Y3RybF9yZXE7Cj4+ICvCoMKgwqAgc3RydWN0IHZpcnRpb19jcnlwdG9fY3RybF9oZWFkZXIgKmhl YWRlcjsKPj4gK8KgwqDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0b19zeW1fY3JlYXRlX3Nlc3Npb25f cmVxICpzeW1fY3JlYXRlX3Nlc3Npb247Cj4+IMKgwqDCoMKgwqAgLyoKPj4gwqDCoMKgwqDCoMKg ICogQXZvaWQgdG8gZG8gRE1BIGZyb20gdGhlIHN0YWNrLCBzd2l0Y2ggdG8gdXNpbmcKPj4gQEAg LTEzMywyNiArMTM1LDI3IEBAIHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJf aW5pdF9zZXNzaW9uKAo+PiDCoMKgwqDCoMKgIGlmICghY2lwaGVyX2tleSkKPj4gwqDCoMKgwqDC oMKgwqDCoMKgIHJldHVybiAtRU5PTUVNOwo+PiAtwqDCoMKgIHNwaW5fbG9jaygmdmNyeXB0by0+ Y3RybF9sb2NrKTsKPj4gK8KgwqDCoCB2Y19jdHJsX3JlcSA9IGt6YWxsb2Moc2l6ZW9mKCp2Y19j dHJsX3JlcSksIEdGUF9LRVJORUwpOwo+PiArwqDCoMKgIGlmICghdmNfY3RybF9yZXEpIHsKPj4g K8KgwqDCoMKgwqDCoMKgIGVyciA9IC1FTk9NRU07Cj4+ICvCoMKgwqDCoMKgwqDCoCBnb3RvIG91 dDsKPj4gK8KgwqDCoCB9Cj4+ICsKPj4gwqDCoMKgwqDCoCAvKiBQYWQgY3RybCBoZWFkZXIgKi8K Pj4gLcKgwqDCoCB2Y3J5cHRvLT5jdHJsLmhlYWRlci5vcGNvZGUgPQo+PiAtwqDCoMKgwqDCoMKg wqAgY3B1X3RvX2xlMzIoVklSVElPX0NSWVBUT19DSVBIRVJfQ1JFQVRFX1NFU1NJT04pOwo+PiAt wqDCoMKgIHZjcnlwdG8tPmN0cmwuaGVhZGVyLmFsZ28gPSBjcHVfdG9fbGUzMihhbGcpOwo+PiAr wqDCoMKgIGhlYWRlciA9ICZ2Y19jdHJsX3JlcS0+Y3RybC5oZWFkZXI7Cj4+ICvCoMKgwqAgaGVh ZGVyLT5vcGNvZGUgPSBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZUFRPX0NJUEhFUl9DUkVBVEVfU0VT U0lPTik7Cj4+ICvCoMKgwqAgaGVhZGVyLT5hbGdvID0gY3B1X3RvX2xlMzIoYWxnKTsKPj4gwqDC oMKgwqDCoCAvKiBTZXQgdGhlIGRlZmF1bHQgZGF0YXF1ZXVlIGlkIHRvIDAgKi8KPj4gLcKgwqDC oCB2Y3J5cHRvLT5jdHJsLmhlYWRlci5xdWV1ZV9pZCA9IDA7Cj4+ICvCoMKgwqAgaGVhZGVyLT5x dWV1ZV9pZCA9IDA7Cj4+IC3CoMKgwqAgdmNyeXB0by0+aW5wdXQuc3RhdHVzID0gY3B1X3RvX2xl MzIoVklSVElPX0NSWVBUT19FUlIpOwo+PiDCoMKgwqDCoMKgIC8qIFBhZCBjaXBoZXIncyBwYXJh bWV0ZXJzICovCj4+IC3CoMKgwqAgdmNyeXB0by0+Y3RybC51LnN5bV9jcmVhdGVfc2Vzc2lvbi5v cF90eXBlID0KPj4gLcKgwqDCoMKgwqDCoMKgIGNwdV90b19sZTMyKFZJUlRJT19DUllQVE9fU1lN X09QX0NJUEhFUik7Cj4+IC3CoMKgwqAgdmNyeXB0by0+Y3RybC51LnN5bV9jcmVhdGVfc2Vzc2lv bi51LmNpcGhlci5wYXJhLmFsZ28gPQo+PiAtwqDCoMKgwqDCoMKgwqAgdmNyeXB0by0+Y3RybC5o ZWFkZXIuYWxnbzsKPj4gLcKgwqDCoCB2Y3J5cHRvLT5jdHJsLnUuc3ltX2NyZWF0ZV9zZXNzaW9u LnUuY2lwaGVyLnBhcmEua2V5bGVuID0KPj4gLcKgwqDCoMKgwqDCoMKgIGNwdV90b19sZTMyKGtl eWxlbik7Cj4+IC3CoMKgwqAgdmNyeXB0by0+Y3RybC51LnN5bV9jcmVhdGVfc2Vzc2lvbi51LmNp cGhlci5wYXJhLm9wID0KPj4gLcKgwqDCoMKgwqDCoMKgIGNwdV90b19sZTMyKG9wKTsKPj4gLQo+ PiAtwqDCoMKgIHNnX2luaXRfb25lKCZvdXRoZHIsICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNy eXB0by0+Y3RybCkpOwo+PiArwqDCoMKgIHN5bV9jcmVhdGVfc2Vzc2lvbiA9ICZ2Y19jdHJsX3Jl cS0+Y3RybC51LnN5bV9jcmVhdGVfc2Vzc2lvbjsKPj4gK8KgwqDCoCBzeW1fY3JlYXRlX3Nlc3Np b24tPm9wX3R5cGUgPSAKPj4gY3B1X3RvX2xlMzIoVklSVElPX0NSWVBUT19TWU1fT1BfQ0lQSEVS KTsKPj4gK8KgwqDCoCBzeW1fY3JlYXRlX3Nlc3Npb24tPnUuY2lwaGVyLnBhcmEuYWxnbyA9IGhl YWRlci0+YWxnbzsKPj4gK8KgwqDCoCBzeW1fY3JlYXRlX3Nlc3Npb24tPnUuY2lwaGVyLnBhcmEu a2V5bGVuID0gY3B1X3RvX2xlMzIoa2V5bGVuKTsKPj4gK8KgwqDCoCBzeW1fY3JlYXRlX3Nlc3Np b24tPnUuY2lwaGVyLnBhcmEub3AgPSBjcHVfdG9fbGUzMihvcCk7Cj4+ICsKPj4gK8KgwqDCoCBz Z19pbml0X29uZSgmb3V0aGRyLCAmdmNfY3RybF9yZXEtPmN0cmwsIHNpemVvZih2Y19jdHJsX3Jl cS0+Y3RybCkpOwo+PiDCoMKgwqDCoMKgIHNnc1tudW1fb3V0KytdID0gJm91dGhkcjsKPj4gwqDC oMKgwqDCoCAvKiBTZXQga2V5ICovCj4+IEBAIC0xNjAsNDUgKzE2MywzNCBAQCBzdGF0aWMgaW50 IHZpcnRpb19jcnlwdG9fYWxnX3NrY2lwaGVyX2luaXRfc2Vzc2lvbigKPj4gwqDCoMKgwqDCoCBz Z3NbbnVtX291dCsrXSA9ICZrZXlfc2c7Cj4+IMKgwqDCoMKgwqAgLyogUmV0dXJuIHN0YXR1cyBh bmQgc2Vzc2lvbiBpZCBiYWNrICovCj4+IC3CoMKgwqAgc2dfaW5pdF9vbmUoJmluaGRyLCAmdmNy eXB0by0+aW5wdXQsIHNpemVvZih2Y3J5cHRvLT5pbnB1dCkpOwo+PiArwqDCoMKgIHZjX2N0cmxf cmVxLT5pbnB1dC5zdGF0dXMgPSBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZUFRPX0VSUik7Cj4+ICvC oMKgwqAgc2dfaW5pdF9vbmUoJmluaGRyLCAmdmNfY3RybF9yZXEtPmlucHV0LCAKPj4gc2l6ZW9m KHZjX2N0cmxfcmVxLT5pbnB1dCkpOwo+PiDCoMKgwqDCoMKgIHNnc1tudW1fb3V0ICsgbnVtX2lu KytdID0gJmluaGRyOwo+PiAtwqDCoMKgIGVyciA9IHZpcnRxdWV1ZV9hZGRfc2dzKHZjcnlwdG8t PmN0cmxfdnEsIHNncywgbnVtX291dCwKPj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBudW1faW4sIHZjcnlwdG8sIEdGUF9BVE9NSUMpOwo+PiAtwqDCoMKgIGlmIChlcnIgPCAwKSB7 Cj4+IC3CoMKgwqDCoMKgwqDCoCBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPj4g LcKgwqDCoMKgwqDCoMKgIGtmcmVlX3NlbnNpdGl2ZShjaXBoZXJfa2V5KTsKPj4gLcKgwqDCoMKg wqDCoMKgIHJldHVybiBlcnI7Cj4+IC3CoMKgwqAgfQo+PiAtwqDCoMKgIHZpcnRxdWV1ZV9raWNr KHZjcnlwdG8tPmN0cmxfdnEpOwo+PiAtCj4+IC3CoMKgwqAgLyoKPj4gLcKgwqDCoMKgICogVHJh cHBpbmcgaW50byB0aGUgaHlwZXJ2aXNvciwgc28gdGhlIHJlcXVlc3Qgc2hvdWxkIGJlCj4+IC3C oMKgwqDCoCAqIGhhbmRsZWQgaW1tZWRpYXRlbHkuCj4+IC3CoMKgwqDCoCAqLwo+PiAtwqDCoMKg IHdoaWxlICghdmlydHF1ZXVlX2dldF9idWYodmNyeXB0by0+Y3RybF92cSwgJnRtcCkgJiYKPj4g LcKgwqDCoMKgwqDCoMKgwqDCoMKgICF2aXJ0cXVldWVfaXNfYnJva2VuKHZjcnlwdG8tPmN0cmxf dnEpKQo+PiAtwqDCoMKgwqDCoMKgwqAgY3B1X3JlbGF4KCk7Cj4+ICvCoMKgwqAgZXJyID0gdmly dGlvX2NyeXB0b19jdHJsX3ZxX3JlcXVlc3QodmNyeXB0bywgc2dzLCBudW1fb3V0LCAKPj4gbnVt X2luLCB2Y19jdHJsX3JlcSk7Cj4+ICvCoMKgwqAgaWYgKGVyciA8IDApCj4+ICvCoMKgwqDCoMKg wqDCoCBnb3RvIG91dDsKPj4gLcKgwqDCoCBpZiAobGUzMl90b19jcHUodmNyeXB0by0+aW5wdXQu c3RhdHVzKSAhPSBWSVJUSU9fQ1JZUFRPX09LKSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCBzcGluX3Vu bG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPj4gK8KgwqDCoCBpZiAobGUzMl90b19jcHUodmNf Y3RybF9yZXEtPmlucHV0LnN0YXR1cykgIT0gVklSVElPX0NSWVBUT19PSykgewo+PiDCoMKgwqDC oMKgwqDCoMKgwqAgcHJfZXJyKCJ2aXJ0aW9fY3J5cHRvOiBDcmVhdGUgc2Vzc2lvbiBmYWlsZWQg c3RhdHVzOiAldVxuIiwKPj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbGUzMl90b19jcHUodmNy eXB0by0+aW5wdXQuc3RhdHVzKSk7Cj4+IC3CoMKgwqDCoMKgwqDCoCBrZnJlZV9zZW5zaXRpdmUo Y2lwaGVyX2tleSk7Cj4+IC3CoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPj4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqAgbGUzMl90b19jcHUodmNfY3RybF9yZXEtPmlucHV0LnN0YXR1cykp Owo+PiArwqDCoMKgwqDCoMKgwqAgZXJyID0gLUVJTlZBTDsKPj4gK8KgwqDCoMKgwqDCoMKgIGdv dG8gb3V0Owo+PiDCoMKgwqDCoMKgIH0KPj4gwqDCoMKgwqDCoCBpZiAoZW5jcnlwdCkKPj4gwqDC oMKgwqDCoMKgwqDCoMKgIGN0eC0+ZW5jX3Nlc3NfaW5mby5zZXNzaW9uX2lkID0KPj4gLcKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgbGU2NF90b19jcHUodmNyeXB0by0+aW5wdXQuc2Vzc2lvbl9pZCk7 Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGxlNjRfdG9fY3B1KHZjX2N0cmxfcmVxLT5pbnB1 dC5zZXNzaW9uX2lkKTsKPj4gwqDCoMKgwqDCoCBlbHNlCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBj dHgtPmRlY19zZXNzX2luZm8uc2Vzc2lvbl9pZCA9Cj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGxlNjRfdG9fY3B1KHZjcnlwdG8tPmlucHV0LnNlc3Npb25faWQpOwo+PiAtCj4+IC3CoMKgwqAg c3Bpbl91bmxvY2soJnZjcnlwdG8tPmN0cmxfbG9jayk7Cj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGxlNjRfdG9fY3B1KHZjX2N0cmxfcmVxLT5pbnB1dC5zZXNzaW9uX2lkKTsKPj4gK8KgwqDC oCBlcnIgPSAwOwo+PiArb3V0Ogo+PiArwqDCoMKgIGtmcmVlKHZjX2N0cmxfcmVxKTsKPj4gwqDC oMKgwqDCoCBrZnJlZV9zZW5zaXRpdmUoY2lwaGVyX2tleSk7Cj4+IC3CoMKgwqAgcmV0dXJuIDA7 Cj4+ICsKPj4gK8KgwqDCoCByZXR1cm4gZXJyOwo+PiDCoCB9Cj4+IMKgIHN0YXRpYyBpbnQgdmly dGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfY2xvc2Vfc2Vzc2lvbigKPj4gQEAgLTIwNiwyMSArMTk4 LDI0IEBAIHN0YXRpYyBpbnQgCj4+IHZpcnRpb19jcnlwdG9fYWxnX3NrY2lwaGVyX2Nsb3NlX3Nl c3Npb24oCj4+IMKgwqDCoMKgwqDCoMKgwqDCoCBpbnQgZW5jcnlwdCkKPj4gwqAgewo+PiDCoMKg wqDCoMKgIHN0cnVjdCBzY2F0dGVybGlzdCBvdXRoZHIsIHN0YXR1c19zZywgKnNnc1syXTsKPj4g LcKgwqDCoCB1bnNpZ25lZCBpbnQgdG1wOwo+PiDCoMKgwqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5 cHRvX2Rlc3Ryb3lfc2Vzc2lvbl9yZXEgKmRlc3Ryb3lfc2Vzc2lvbjsKPj4gwqDCoMKgwqDCoCBz dHJ1Y3QgdmlydGlvX2NyeXB0byAqdmNyeXB0byA9IGN0eC0+dmNyeXB0bzsKPj4gwqDCoMKgwqDC oCBpbnQgZXJyOwo+PiDCoMKgwqDCoMKgIHVuc2lnbmVkIGludCBudW1fb3V0ID0gMCwgbnVtX2lu ID0gMDsKPj4gK8KgwqDCoCBzdHJ1Y3QgdmlydGlvX2NyeXB0b19jdHJsX3JlcXVlc3QgKnZjX2N0 cmxfcmVxOwo+PiArwqDCoMKgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2N0cmxfaGVhZGVyICpoZWFk ZXI7Cj4+ICsKPj4gK8KgwqDCoCB2Y19jdHJsX3JlcSA9IGt6YWxsb2Moc2l6ZW9mKCp2Y19jdHJs X3JlcSksIEdGUF9LRVJORUwpOwo+PiArwqDCoMKgIGlmICghdmNfY3RybF9yZXEpCj4+ICvCoMKg wqDCoMKgwqDCoCByZXR1cm4gLUVOT01FTTsKPj4gLcKgwqDCoCBzcGluX2xvY2soJnZjcnlwdG8t PmN0cmxfbG9jayk7Cj4+IC3CoMKgwqAgdmNyeXB0by0+Y3RybF9zdGF0dXMuc3RhdHVzID0gVklS VElPX0NSWVBUT19FUlI7Cj4+IMKgwqDCoMKgwqAgLyogUGFkIGN0cmwgaGVhZGVyICovCj4+IC3C oMKgwqAgdmNyeXB0by0+Y3RybC5oZWFkZXIub3Bjb2RlID0KPj4gLcKgwqDCoMKgwqDCoMKgIGNw dV90b19sZTMyKFZJUlRJT19DUllQVE9fQ0lQSEVSX0RFU1RST1lfU0VTU0lPTik7Cj4+ICvCoMKg wqAgaGVhZGVyID0gJnZjX2N0cmxfcmVxLT5jdHJsLmhlYWRlcjsKPj4gK8KgwqDCoCBoZWFkZXIt Pm9wY29kZSA9IGNwdV90b19sZTMyKFZJUlRJT19DUllQVE9fQ0lQSEVSX0RFU1RST1lfU0VTU0lP Tik7Cj4+IMKgwqDCoMKgwqAgLyogU2V0IHRoZSBkZWZhdWx0IHZpcnRxdWV1ZSBpZCB0byAwICov Cj4+IC3CoMKgwqAgdmNyeXB0by0+Y3RybC5oZWFkZXIucXVldWVfaWQgPSAwOwo+PiArwqDCoMKg IGhlYWRlci0+cXVldWVfaWQgPSAwOwo+PiAtwqDCoMKgIGRlc3Ryb3lfc2Vzc2lvbiA9ICZ2Y3J5 cHRvLT5jdHJsLnUuZGVzdHJveV9zZXNzaW9uOwo+PiArwqDCoMKgIGRlc3Ryb3lfc2Vzc2lvbiA9 ICZ2Y19jdHJsX3JlcS0+Y3RybC51LmRlc3Ryb3lfc2Vzc2lvbjsKPj4gwqDCoMKgwqDCoCBpZiAo ZW5jcnlwdCkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIGRlc3Ryb3lfc2Vzc2lvbi0+c2Vzc2lvbl9p ZCA9Cj4+IEBAIC0yMjksMzcgKzIyNCwzMyBAQCBzdGF0aWMgaW50IAo+PiB2aXJ0aW9fY3J5cHRv X2FsZ19za2NpcGhlcl9jbG9zZV9zZXNzaW9uKAo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgZGVzdHJv eV9zZXNzaW9uLT5zZXNzaW9uX2lkID0KPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY3B1 X3RvX2xlNjQoY3R4LT5kZWNfc2Vzc19pbmZvLnNlc3Npb25faWQpOwo+PiAtwqDCoMKgIHNnX2lu aXRfb25lKCZvdXRoZHIsICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNyeXB0by0+Y3RybCkpOwo+ PiArwqDCoMKgIHNnX2luaXRfb25lKCZvdXRoZHIsICZ2Y19jdHJsX3JlcS0+Y3RybCwgc2l6ZW9m KHZjX2N0cmxfcmVxLT5jdHJsKSk7Cj4+IMKgwqDCoMKgwqAgc2dzW251bV9vdXQrK10gPSAmb3V0 aGRyOwo+PiDCoMKgwqDCoMKgIC8qIFJldHVybiBzdGF0dXMgYW5kIHNlc3Npb24gaWQgYmFjayAq Lwo+PiAtwqDCoMKgIHNnX2luaXRfb25lKCZzdGF0dXNfc2csICZ2Y3J5cHRvLT5jdHJsX3N0YXR1 cy5zdGF0dXMsCj4+IC3CoMKgwqDCoMKgwqDCoCBzaXplb2YodmNyeXB0by0+Y3RybF9zdGF0dXMu c3RhdHVzKSk7Cj4+ICvCoMKgwqAgdmNfY3RybF9yZXEtPmN0cmxfc3RhdHVzLnN0YXR1cyA9IFZJ UlRJT19DUllQVE9fRVJSOwo+PiArwqDCoMKgIHNnX2luaXRfb25lKCZzdGF0dXNfc2csICZ2Y19j dHJsX3JlcS0+Y3RybF9zdGF0dXMuc3RhdHVzLAo+PiArwqDCoMKgwqDCoMKgwqAgc2l6ZW9mKHZj X2N0cmxfcmVxLT5jdHJsX3N0YXR1cy5zdGF0dXMpKTsKPj4gwqDCoMKgwqDCoCBzZ3NbbnVtX291 dCArIG51bV9pbisrXSA9ICZzdGF0dXNfc2c7Cj4+IC3CoMKgwqAgZXJyID0gdmlydHF1ZXVlX2Fk ZF9zZ3ModmNyeXB0by0+Y3RybF92cSwgc2dzLCBudW1fb3V0LAo+PiAtwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBudW1faW4sIHZjcnlwdG8sIEdGUF9BVE9NSUMpOwo+PiAtwqDCoMKgIGlmIChlcnIg PCAwKSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2Nr KTsKPj4gLcKgwqDCoMKgwqDCoMKgIHJldHVybiBlcnI7Cj4+IC3CoMKgwqAgfQo+PiAtwqDCoMKg IHZpcnRxdWV1ZV9raWNrKHZjcnlwdG8tPmN0cmxfdnEpOwo+PiAtCj4+IC3CoMKgwqAgd2hpbGUg KCF2aXJ0cXVldWVfZ2V0X2J1Zih2Y3J5cHRvLT5jdHJsX3ZxLCAmdG1wKSAmJgo+PiAtwqDCoMKg wqDCoMKgwqDCoMKgwqAgIXZpcnRxdWV1ZV9pc19icm9rZW4odmNyeXB0by0+Y3RybF92cSkpCj4+ IC3CoMKgwqDCoMKgwqDCoCBjcHVfcmVsYXgoKTsKPj4gK8KgwqDCoCBlcnIgPSB2aXJ0aW9fY3J5 cHRvX2N0cmxfdnFfcmVxdWVzdCh2Y3J5cHRvLCBzZ3MsIG51bV9vdXQsIAo+PiBudW1faW4sIHZj X2N0cmxfcmVxKTsKPj4gK8KgwqDCoCBpZiAoZXJyIDwgMCkKPj4gK8KgwqDCoMKgwqDCoMKgIGdv dG8gb3V0Owo+PiAtwqDCoMKgIGlmICh2Y3J5cHRvLT5jdHJsX3N0YXR1cy5zdGF0dXMgIT0gVklS VElPX0NSWVBUT19PSykgewo+PiAtwqDCoMKgwqDCoMKgwqAgc3Bpbl91bmxvY2soJnZjcnlwdG8t PmN0cmxfbG9jayk7Cj4+ICvCoMKgwqAgaWYgKHZjX2N0cmxfcmVxLT5jdHJsX3N0YXR1cy5zdGF0 dXMgIT0gVklSVElPX0NSWVBUT19PSykgewo+PiDCoMKgwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCJ2 aXJ0aW9fY3J5cHRvOiBDbG9zZSBzZXNzaW9uIGZhaWxlZCBzdGF0dXM6ICV1LCAKPj4gc2Vzc2lv bl9pZDogMHglbGx4XG4iLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2Y3J5cHRvLT5jdHJs X3N0YXR1cy5zdGF0dXMsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZjX2N0cmxfcmVxLT5j dHJsX3N0YXR1cy5zdGF0dXMsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlc3Ryb3lf c2Vzc2lvbi0+c2Vzc2lvbl9pZCk7Cj4+IC3CoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsK Pj4gK8KgwqDCoMKgwqDCoMKgIGVyciA9IC1FSU5WQUw7Cj4+ICvCoMKgwqDCoMKgwqDCoCBnb3Rv IG91dDsKPj4gwqDCoMKgwqDCoCB9Cj4+IC3CoMKgwqAgc3Bpbl91bmxvY2soJnZjcnlwdG8tPmN0 cmxfbG9jayk7Cj4+IC3CoMKgwqAgcmV0dXJuIDA7Cj4+ICvCoMKgwqAgZXJyID0gMDsKPj4gK291 dDoKPj4gK8KgwqDCoCBrZnJlZSh2Y19jdHJsX3JlcSk7Cj4+ICsKPj4gK8KgwqDCoCByZXR1cm4g ZXJyOwo+PiDCoCB9Cj4+IMKgIHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJf aW5pdF9zZXNzaW9ucygKPiAKCi0tIAp6aGVud2VpIHBpCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApWaXJ0 dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4 Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg== 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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9AF19C433F5 for ; Fri, 22 Apr 2022 09:14:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233686AbiDVJQ4 (ORCPT ); Fri, 22 Apr 2022 05:16:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60764 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1445898AbiDVJO6 (ORCPT ); Fri, 22 Apr 2022 05:14:58 -0400 Received: from mail-pf1-x436.google.com (mail-pf1-x436.google.com [IPv6:2607:f8b0:4864:20::436]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4A4AD51E74 for ; Fri, 22 Apr 2022 02:12:05 -0700 (PDT) Received: by mail-pf1-x436.google.com with SMTP id bo5so7435980pfb.4 for ; Fri, 22 Apr 2022 02:12:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=message-id:date:mime-version:user-agent:subject:content-language:to :cc:references:from:in-reply-to:content-transfer-encoding; bh=3hPshux/9mpgfrkX7ChnlAe//9FupZFlffa+u2LwKpM=; b=xTvCgxufTFlMC/sf7og0zUG1bRyD+jrunR+CqasxGc8nBYbtis0rfo1qv3Orb286d9 c+L/DCifYwicRQhgwlkSQQN7q31/7jkieLw/Z5xSwpBk363OnbhL0yMqT5D5E+C4WEXA lZGN7RujL5sW4JXxYfmJcYmK2MNEoy7v/pmFxZ8ILycSm082vKS0bO1l8GHCF8Se5Yep q25uFnEhXAgHLu36N2gNS+m20uHdadTrgQBMydXsIQ4JbWeSMqa3d7bK07+78rZbCZ/O Vdw3/hxm5nc88ziGhrzEWYw9EpyARQOe3fhDyKRk/MBxoKHyqZeOA9rcHT2I9hEb1FDy +kgg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to :content-transfer-encoding; bh=3hPshux/9mpgfrkX7ChnlAe//9FupZFlffa+u2LwKpM=; b=2jcjK8zfrbgtgO6R0r2qZ2egcMaXvhVNOZekET4bEEGbwEGn5qOjsrTSV2IfVl2IG6 NEBiXZ+Pwavc+OHt1zOwgjUOLycCzKw8bXlLwOdr3uNvGuCwufTazDF1CsmpusFKVR5S +JPB2JqPvU5g3PvxhrwgSYGcna77NbQSjc5XMOa+mCJNekgiGNsSU9lzyGb9t9u/UZpB bpYHOtyN9IeqGxQrw71KgbabRWSkpR4Agzeq4MmcQoXrNGde5Wjg+njUQcg6pkimTQNZ SUAsyIx37ixYQ5RW0agHFA11tMD4P5FyNgjK2cQmMviNqY1N5piFah/Q+Hv8ix1/xxeL 4hxQ== X-Gm-Message-State: AOAM530pWO1Jcns7sNrpofqGW6pnNFsXPeCkgICXazKAQN1Qo3Rrgqbe sVzZN9wqQfoP/8PiNNGr614wWlTN6/3K5Q== X-Google-Smtp-Source: ABdhPJxuGB3YAK/6R1hHmiKbFnv6kqR2cpmryF9yAyjF3GRPg2W6rJcxjTdcdtDe82SsMMhxkTIMJw== X-Received: by 2002:a63:4101:0:b0:3aa:6375:e5f4 with SMTP id o1-20020a634101000000b003aa6375e5f4mr3089276pga.240.1650618724758; Fri, 22 Apr 2022 02:12:04 -0700 (PDT) Received: from [10.76.15.169] ([61.120.150.70]) by smtp.gmail.com with ESMTPSA id c16-20020a631c50000000b003a39244fe8esm1572546pgm.68.2022.04.22.02.12.00 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 22 Apr 2022 02:12:04 -0700 (PDT) Message-ID: Date: Fri, 22 Apr 2022 17:08:13 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.7.0 Subject: Re: Re: [PATCH v3 1/5] virtio-crypto: use private buffer for control request Content-Language: en-US To: Jason Wang , arei.gonglei@huawei.com, mst@redhat.com Cc: herbert@gondor.apana.org.au, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, linux-crypto@vger.kernel.org, helei.sig11@bytedance.com, davem@davemloft.net References: <20220421104016.453458-1-pizhenwei@bytedance.com> <20220421104016.453458-2-pizhenwei@bytedance.com> <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> From: zhenwei pi In-Reply-To: <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org On 4/22/22 15:41, Jason Wang wrote: > > 在 2022/4/21 18:40, zhenwei pi 写道: >> Originally, all of the control requests share a single buffer( >> ctrl & input & ctrl_status fields in struct virtio_crypto), this >> allows queue depth 1 only, the performance of control queue gets >> limited by this design. >> >> In this patch, each request allocates request buffer dynamically, and >> free buffer after request, it's possible to optimize control queue >> depth in the next step. >> >> A necessary comment is already in code, still describe it again: >> /* >>   * Note: there are padding fields in request, clear them to zero before >>   * sending to host, >>   * Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[48] >>   */ >> So use kzalloc to allocate buffer of struct virtio_crypto_ctrl_request. >> >> Cc: Michael S. Tsirkin >> Cc: Jason Wang >> Cc: Gonglei >> Signed-off-by: zhenwei pi >> --- >>   drivers/crypto/virtio/Makefile                |   1 + >>   .../virtio/virtio_crypto_akcipher_algs.c      |  90 ++++++------ >>   drivers/crypto/virtio/virtio_crypto_common.c  |  39 +++++ > > > Any reason we can't use virtio_crypto_core.c? > Another patch in this series: [PATCH v3 3/5] virtio-crypto: move helpers into virtio_crypto_common.c Move virtcrypto_clear_request and virtcrypto_dataq_callback into virtio_crypto_common.c to make code clear. Then the xx_core.c supports: - probe/remove/irq affinity seting for a virtio device - basic virtio related operations xx_common.c supports: - common helpers/functions for algos So I put this into a new file. > >>   drivers/crypto/virtio/virtio_crypto_common.h  |  19 ++- >>   .../virtio/virtio_crypto_skcipher_algs.c      | 133 ++++++++---------- >>   5 files changed, 156 insertions(+), 126 deletions(-) >>   create mode 100644 drivers/crypto/virtio/virtio_crypto_common.c >> >> diff --git a/drivers/crypto/virtio/Makefile >> b/drivers/crypto/virtio/Makefile >> index bfa6cbae342e..49c1fa80e465 100644 >> --- a/drivers/crypto/virtio/Makefile >> +++ b/drivers/crypto/virtio/Makefile >> @@ -3,5 +3,6 @@ obj-$(CONFIG_CRYPTO_DEV_VIRTIO) += virtio_crypto.o >>   virtio_crypto-objs := \ >>       virtio_crypto_skcipher_algs.o \ >>       virtio_crypto_akcipher_algs.o \ >> +    virtio_crypto_common.o \ >>       virtio_crypto_mgr.o \ >>       virtio_crypto_core.o >> diff --git a/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c >> b/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c >> index f3ec9420215e..9561bc2df62b 100644 >> --- a/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c >> +++ b/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c >> @@ -102,8 +102,8 @@ static int >> virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher >>   { >>       struct scatterlist outhdr_sg, key_sg, inhdr_sg, *sgs[3]; >>       struct virtio_crypto *vcrypto = ctx->vcrypto; >> +    struct virtio_crypto_ctrl_request *vc_ctrl_req; >>       uint8_t *pkey; >> -    unsigned int inlen; >>       int err; >>       unsigned int num_out = 0, num_in = 0; >> @@ -111,98 +111,91 @@ static int >> virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher >>       if (!pkey) >>           return -ENOMEM; >> -    spin_lock(&vcrypto->ctrl_lock); >> -    memcpy(&vcrypto->ctrl.header, header, sizeof(vcrypto->ctrl.header)); >> -    memcpy(&vcrypto->ctrl.u, para, sizeof(vcrypto->ctrl.u)); >> -    vcrypto->input.status = cpu_to_le32(VIRTIO_CRYPTO_ERR); >> +    vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); >> +    if (!vc_ctrl_req) { >> +        err = -ENOMEM; >> +        goto out; >> +    } >> -    sg_init_one(&outhdr_sg, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); >> +    memcpy(&vc_ctrl_req->ctrl.header, header, >> sizeof(vc_ctrl_req->ctrl.header)); >> +    memcpy(&vc_ctrl_req->ctrl.u, para, sizeof(vc_ctrl_req->ctrl.u)); >> +    sg_init_one(&outhdr_sg, &vc_ctrl_req->ctrl, >> sizeof(vc_ctrl_req->ctrl)); >>       sgs[num_out++] = &outhdr_sg; >>       sg_init_one(&key_sg, pkey, keylen); >>       sgs[num_out++] = &key_sg; >> -    sg_init_one(&inhdr_sg, &vcrypto->input, sizeof(vcrypto->input)); >> +    vc_ctrl_req->input.status = cpu_to_le32(VIRTIO_CRYPTO_ERR); > > > Nit: if there's no special reason, let's move this after the above > memcpys as what's done previously. > > >> +    sg_init_one(&inhdr_sg, &vc_ctrl_req->input, >> sizeof(vc_ctrl_req->input)); >>       sgs[num_out + num_in++] = &inhdr_sg; >> -    err = virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, num_in, >> vcrypto, GFP_ATOMIC); >> +    err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, >> num_in, vc_ctrl_req); > > > I'd split this into a separate patch. > OK! > >>       if (err < 0) >>           goto out; >> -    virtqueue_kick(vcrypto->ctrl_vq); >> -    while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && >> -           !virtqueue_is_broken(vcrypto->ctrl_vq)) >> -        cpu_relax(); >> - >> -    if (le32_to_cpu(vcrypto->input.status) != VIRTIO_CRYPTO_OK) { >> +    if (le32_to_cpu(vc_ctrl_req->input.status) != VIRTIO_CRYPTO_OK) { >> +        pr_err("virtio_crypto: Create session failed status: %u\n", >> +            le32_to_cpu(vc_ctrl_req->input.status)); >>           err = -EINVAL; >>           goto out; >>       } > > > Do we need a warning for -ENOMEM? > Memory(especially small size) allocation is unlikely case, I also check the virtio_net and virtio_blk, both handles -ENOMEM only without error reporting. > >> -    ctx->session_id = le64_to_cpu(vcrypto->input.session_id); >> +    ctx->session_id = le64_to_cpu(vc_ctrl_req->input.session_id); >>       ctx->session_valid = true; >>       err = 0; >>   out: >> -    spin_unlock(&vcrypto->ctrl_lock); >> +    kfree(vc_ctrl_req); >>       kfree_sensitive(pkey); >> -    if (err < 0) >> -        pr_err("virtio_crypto: Create session failed status: %u\n", >> -            le32_to_cpu(vcrypto->input.status)); >> - >>       return err; >>   } >>   static int virtio_crypto_alg_akcipher_close_session(struct >> virtio_crypto_akcipher_ctx *ctx) >>   { >>       struct scatterlist outhdr_sg, inhdr_sg, *sgs[2]; >> +    struct virtio_crypto_ctrl_request *vc_ctrl_req; >>       struct virtio_crypto_destroy_session_req *destroy_session; >>       struct virtio_crypto *vcrypto = ctx->vcrypto; >> -    unsigned int num_out = 0, num_in = 0, inlen; >> +    unsigned int num_out = 0, num_in = 0; >>       int err; >> -    spin_lock(&vcrypto->ctrl_lock); >> -    if (!ctx->session_valid) { >> -        err = 0; >> -        goto out; >> -    } >> -    vcrypto->ctrl_status.status = VIRTIO_CRYPTO_ERR; >> -    vcrypto->ctrl.header.opcode = >> cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); >> -    vcrypto->ctrl.header.queue_id = 0; >> +    if (!ctx->session_valid) >> +        return 0; >> -    destroy_session = &vcrypto->ctrl.u.destroy_session; >> +    vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); >> +    if (!vc_ctrl_req) >> +        return -ENOMEM; >> + >> +    vc_ctrl_req->ctrl.header.opcode = >> cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); >> +    vc_ctrl_req->ctrl.header.queue_id = 0; >> + >> +    destroy_session = &vc_ctrl_req->ctrl.u.destroy_session; >>       destroy_session->session_id = cpu_to_le64(ctx->session_id); >> -    sg_init_one(&outhdr_sg, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); >> +    sg_init_one(&outhdr_sg, &vc_ctrl_req->ctrl, >> sizeof(vc_ctrl_req->ctrl)); >>       sgs[num_out++] = &outhdr_sg; >> -    sg_init_one(&inhdr_sg, &vcrypto->ctrl_status.status, >> sizeof(vcrypto->ctrl_status.status)); >> +    vc_ctrl_req->ctrl_status.status = VIRTIO_CRYPTO_ERR; > > > If no special reason, let's move this above: > > vc_ctrl_req->ctrl.header.opcode = > cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); > OK! > >> +    sg_init_one(&inhdr_sg, &vc_ctrl_req->ctrl_status.status, >> +        sizeof(vc_ctrl_req->ctrl_status.status)); >>       sgs[num_out + num_in++] = &inhdr_sg; >> -    err = virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, num_in, >> vcrypto, GFP_ATOMIC); >> +    err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, >> num_in, vc_ctrl_req); >>       if (err < 0) >>           goto out; >> -    virtqueue_kick(vcrypto->ctrl_vq); >> -    while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && >> -           !virtqueue_is_broken(vcrypto->ctrl_vq)) >> -        cpu_relax(); >> - >> -    if (vcrypto->ctrl_status.status != VIRTIO_CRYPTO_OK) { >> +    if (vc_ctrl_req->ctrl_status.status != VIRTIO_CRYPTO_OK) { >>           err = -EINVAL; >> +        pr_err("virtio_crypto: Close session failed status: %u, >> session_id: 0x%llx\n", >> +            vc_ctrl_req->ctrl_status.status, >> destroy_session->session_id); >>           goto out; >>       } >>       err = 0; >>       ctx->session_valid = false; >> - >>   out: >> -    spin_unlock(&vcrypto->ctrl_lock); >> -    if (err < 0) { >> -        pr_err("virtio_crypto: Close session failed status: %u, >> session_id: 0x%llx\n", >> -            vcrypto->ctrl_status.status, destroy_session->session_id); >> -    } >> +    kfree(vc_ctrl_req); >>       return err; >>   } >> @@ -210,14 +203,11 @@ static int >> virtio_crypto_alg_akcipher_close_session(struct virtio_crypto_akciphe >>   static int __virtio_crypto_akcipher_do_req(struct >> virtio_crypto_akcipher_request *vc_akcipher_req, >>           struct akcipher_request *req, struct data_queue *data_vq) >>   { >> -    struct virtio_crypto_akcipher_ctx *ctx = >> vc_akcipher_req->akcipher_ctx; >>       struct virtio_crypto_request *vc_req = &vc_akcipher_req->base; >> -    struct virtio_crypto *vcrypto = ctx->vcrypto; >>       struct virtio_crypto_op_data_req *req_data = vc_req->req_data; >>       struct scatterlist *sgs[4], outhdr_sg, inhdr_sg, srcdata_sg, >> dstdata_sg; >>       void *src_buf = NULL, *dst_buf = NULL; >>       unsigned int num_out = 0, num_in = 0; >> -    int node = dev_to_node(&vcrypto->vdev->dev); >>       unsigned long flags; >>       int ret = -ENOMEM; >>       bool verify = vc_akcipher_req->opcode == >> VIRTIO_CRYPTO_AKCIPHER_VERIFY; >> @@ -228,7 +218,7 @@ static int __virtio_crypto_akcipher_do_req(struct >> virtio_crypto_akcipher_request >>       sgs[num_out++] = &outhdr_sg; >>       /* src data */ >> -    src_buf = kcalloc_node(src_len, 1, GFP_KERNEL, node); >> +    src_buf = kcalloc(src_len, 1, GFP_KERNEL); > > > This seems not a relevant change. If it is a must we need use a separate > for this and describe the rationale. > > >>       if (!src_buf) >>           goto err; >> @@ -243,7 +233,7 @@ static int __virtio_crypto_akcipher_do_req(struct >> virtio_crypto_akcipher_request >>           sgs[num_out++] = &srcdata_sg; >>           /* dst data */ >> -        dst_buf = kcalloc_node(req->dst_len, 1, GFP_KERNEL, node); >> +        dst_buf = kcalloc(req->dst_len, 1, GFP_KERNEL); > > > And this. > > >>           if (!dst_buf) >>               goto err; >> diff --git a/drivers/crypto/virtio/virtio_crypto_common.c >> b/drivers/crypto/virtio/virtio_crypto_common.c >> new file mode 100644 >> index 000000000000..e65125a74db2 >> --- /dev/null >> +++ b/drivers/crypto/virtio/virtio_crypto_common.c >> @@ -0,0 +1,39 @@ >> +// SPDX-License-Identifier: GPL-2.0-or-later >> +/* Common functions and helpers >> + * >> + * Authors: zhenwei pi >> + * >> + * Copyright 2022 Bytedance CO., LTD. >> + */ >> + >> +#include "virtio_crypto_common.h" >> + >> +int virtio_crypto_ctrl_vq_request(struct virtio_crypto *vcrypto, >> struct scatterlist *sgs[], >> +                  unsigned int out_sgs, unsigned int in_sgs, >> +                  struct virtio_crypto_ctrl_request *vc_ctrl_req) >> +{ >> +    int err; >> +    unsigned int inlen; >> +    unsigned long flags; >> + >> +    spin_lock_irqsave(&vcrypto->ctrl_lock, flags); >> +    err = virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, out_sgs, in_sgs, >> vc_ctrl_req, GFP_ATOMIC); >> +    if (err < 0) { >> +        spin_unlock_irqrestore(&vcrypto->ctrl_lock, flags); >> +        return err; >> +    } >> + >> +    virtqueue_kick(vcrypto->ctrl_vq); >> + >> +    /* >> +     * Trapping into the hypervisor, so the request should be >> +     * handled immediately. >> +     */ >> +    while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && >> +        !virtqueue_is_broken(vcrypto->ctrl_vq)) >> +        cpu_relax(); >> + >> +    spin_unlock_irqrestore(&vcrypto->ctrl_lock, flags); >> + >> +    return 0; >> +} >> diff --git a/drivers/crypto/virtio/virtio_crypto_common.h >> b/drivers/crypto/virtio/virtio_crypto_common.h >> index e693d4ee83a6..d2a20fe6e13e 100644 >> --- a/drivers/crypto/virtio/virtio_crypto_common.h >> +++ b/drivers/crypto/virtio/virtio_crypto_common.h >> @@ -13,6 +13,7 @@ >>   #include >>   #include >>   #include >> +#include >>   /* Internal representation of a data virtqueue */ >> @@ -65,11 +66,6 @@ struct virtio_crypto { >>       /* Maximum size of per request */ >>       u64 max_size; >> -    /* Control VQ buffers: protected by the ctrl_lock */ >> -    struct virtio_crypto_op_ctrl_req ctrl; >> -    struct virtio_crypto_session_input input; >> -    struct virtio_crypto_inhdr ctrl_status; >> - >>       unsigned long status; >>       atomic_t ref_count; >>       struct list_head list; >> @@ -85,6 +81,16 @@ struct virtio_crypto_sym_session_info { >>       __u64 session_id; >>   }; >> +/* >> + * Note: there are padding fields in request, clear them to zero >> before sending to host, >> + * Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[48] >> + */ >> +struct virtio_crypto_ctrl_request { >> +    struct virtio_crypto_op_ctrl_req ctrl; >> +    struct virtio_crypto_session_input input; >> +    struct virtio_crypto_inhdr ctrl_status; >> +}; >> + >>   struct virtio_crypto_request; >>   typedef void (*virtio_crypto_data_callback) >>           (struct virtio_crypto_request *vc_req, int len); >> @@ -135,4 +141,7 @@ void virtio_crypto_skcipher_algs_unregister(struct >> virtio_crypto *vcrypto); >>   int virtio_crypto_akcipher_algs_register(struct virtio_crypto >> *vcrypto); >>   void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto >> *vcrypto); >> +int virtio_crypto_ctrl_vq_request(struct virtio_crypto *vcrypto, >> struct scatterlist *sgs[], >> +                  unsigned int out_sgs, unsigned int in_sgs, >> +                  struct virtio_crypto_ctrl_request *vc_ctrl_req); >>   #endif /* _VIRTIO_CRYPTO_COMMON_H */ >> diff --git a/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c >> b/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c >> index a618c46a52b8..fef355ff461c 100644 >> --- a/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c >> +++ b/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c >> @@ -118,11 +118,13 @@ static int virtio_crypto_alg_skcipher_init_session( >>           int encrypt) >>   { >>       struct scatterlist outhdr, key_sg, inhdr, *sgs[3]; >> -    unsigned int tmp; >>       struct virtio_crypto *vcrypto = ctx->vcrypto; > > > Can we simply rename this to virtcrypto and then we can use the name > "vcrypto" for virtio_crypto_ctrl_request then we save tons lot changes? > > It simplify the life of reviewers and backporting. > > Thanks > This series focuses on performance improvment, and keeps the style with the orignal style. What about fixing this in another series? (If so, I'll fix this later) > >>       int op = encrypt ? VIRTIO_CRYPTO_OP_ENCRYPT : >> VIRTIO_CRYPTO_OP_DECRYPT; >>       int err; >>       unsigned int num_out = 0, num_in = 0; >> +    struct virtio_crypto_ctrl_request *vc_ctrl_req; >> +    struct virtio_crypto_ctrl_header *header; >> +    struct virtio_crypto_sym_create_session_req *sym_create_session; >>       /* >>        * Avoid to do DMA from the stack, switch to using >> @@ -133,26 +135,27 @@ static int virtio_crypto_alg_skcipher_init_session( >>       if (!cipher_key) >>           return -ENOMEM; >> -    spin_lock(&vcrypto->ctrl_lock); >> +    vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); >> +    if (!vc_ctrl_req) { >> +        err = -ENOMEM; >> +        goto out; >> +    } >> + >>       /* Pad ctrl header */ >> -    vcrypto->ctrl.header.opcode = >> -        cpu_to_le32(VIRTIO_CRYPTO_CIPHER_CREATE_SESSION); >> -    vcrypto->ctrl.header.algo = cpu_to_le32(alg); >> +    header = &vc_ctrl_req->ctrl.header; >> +    header->opcode = cpu_to_le32(VIRTIO_CRYPTO_CIPHER_CREATE_SESSION); >> +    header->algo = cpu_to_le32(alg); >>       /* Set the default dataqueue id to 0 */ >> -    vcrypto->ctrl.header.queue_id = 0; >> +    header->queue_id = 0; >> -    vcrypto->input.status = cpu_to_le32(VIRTIO_CRYPTO_ERR); >>       /* Pad cipher's parameters */ >> -    vcrypto->ctrl.u.sym_create_session.op_type = >> -        cpu_to_le32(VIRTIO_CRYPTO_SYM_OP_CIPHER); >> -    vcrypto->ctrl.u.sym_create_session.u.cipher.para.algo = >> -        vcrypto->ctrl.header.algo; >> -    vcrypto->ctrl.u.sym_create_session.u.cipher.para.keylen = >> -        cpu_to_le32(keylen); >> -    vcrypto->ctrl.u.sym_create_session.u.cipher.para.op = >> -        cpu_to_le32(op); >> - >> -    sg_init_one(&outhdr, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); >> +    sym_create_session = &vc_ctrl_req->ctrl.u.sym_create_session; >> +    sym_create_session->op_type = >> cpu_to_le32(VIRTIO_CRYPTO_SYM_OP_CIPHER); >> +    sym_create_session->u.cipher.para.algo = header->algo; >> +    sym_create_session->u.cipher.para.keylen = cpu_to_le32(keylen); >> +    sym_create_session->u.cipher.para.op = cpu_to_le32(op); >> + >> +    sg_init_one(&outhdr, &vc_ctrl_req->ctrl, sizeof(vc_ctrl_req->ctrl)); >>       sgs[num_out++] = &outhdr; >>       /* Set key */ >> @@ -160,45 +163,34 @@ static int virtio_crypto_alg_skcipher_init_session( >>       sgs[num_out++] = &key_sg; >>       /* Return status and session id back */ >> -    sg_init_one(&inhdr, &vcrypto->input, sizeof(vcrypto->input)); >> +    vc_ctrl_req->input.status = cpu_to_le32(VIRTIO_CRYPTO_ERR); >> +    sg_init_one(&inhdr, &vc_ctrl_req->input, >> sizeof(vc_ctrl_req->input)); >>       sgs[num_out + num_in++] = &inhdr; >> -    err = virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, >> -                num_in, vcrypto, GFP_ATOMIC); >> -    if (err < 0) { >> -        spin_unlock(&vcrypto->ctrl_lock); >> -        kfree_sensitive(cipher_key); >> -        return err; >> -    } >> -    virtqueue_kick(vcrypto->ctrl_vq); >> - >> -    /* >> -     * Trapping into the hypervisor, so the request should be >> -     * handled immediately. >> -     */ >> -    while (!virtqueue_get_buf(vcrypto->ctrl_vq, &tmp) && >> -           !virtqueue_is_broken(vcrypto->ctrl_vq)) >> -        cpu_relax(); >> +    err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, >> num_in, vc_ctrl_req); >> +    if (err < 0) >> +        goto out; >> -    if (le32_to_cpu(vcrypto->input.status) != VIRTIO_CRYPTO_OK) { >> -        spin_unlock(&vcrypto->ctrl_lock); >> +    if (le32_to_cpu(vc_ctrl_req->input.status) != VIRTIO_CRYPTO_OK) { >>           pr_err("virtio_crypto: Create session failed status: %u\n", >> -            le32_to_cpu(vcrypto->input.status)); >> -        kfree_sensitive(cipher_key); >> -        return -EINVAL; >> +            le32_to_cpu(vc_ctrl_req->input.status)); >> +        err = -EINVAL; >> +        goto out; >>       } >>       if (encrypt) >>           ctx->enc_sess_info.session_id = >> -            le64_to_cpu(vcrypto->input.session_id); >> +            le64_to_cpu(vc_ctrl_req->input.session_id); >>       else >>           ctx->dec_sess_info.session_id = >> -            le64_to_cpu(vcrypto->input.session_id); >> - >> -    spin_unlock(&vcrypto->ctrl_lock); >> +            le64_to_cpu(vc_ctrl_req->input.session_id); >> +    err = 0; >> +out: >> +    kfree(vc_ctrl_req); >>       kfree_sensitive(cipher_key); >> -    return 0; >> + >> +    return err; >>   } >>   static int virtio_crypto_alg_skcipher_close_session( >> @@ -206,21 +198,24 @@ static int >> virtio_crypto_alg_skcipher_close_session( >>           int encrypt) >>   { >>       struct scatterlist outhdr, status_sg, *sgs[2]; >> -    unsigned int tmp; >>       struct virtio_crypto_destroy_session_req *destroy_session; >>       struct virtio_crypto *vcrypto = ctx->vcrypto; >>       int err; >>       unsigned int num_out = 0, num_in = 0; >> +    struct virtio_crypto_ctrl_request *vc_ctrl_req; >> +    struct virtio_crypto_ctrl_header *header; >> + >> +    vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); >> +    if (!vc_ctrl_req) >> +        return -ENOMEM; >> -    spin_lock(&vcrypto->ctrl_lock); >> -    vcrypto->ctrl_status.status = VIRTIO_CRYPTO_ERR; >>       /* Pad ctrl header */ >> -    vcrypto->ctrl.header.opcode = >> -        cpu_to_le32(VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION); >> +    header = &vc_ctrl_req->ctrl.header; >> +    header->opcode = cpu_to_le32(VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION); >>       /* Set the default virtqueue id to 0 */ >> -    vcrypto->ctrl.header.queue_id = 0; >> +    header->queue_id = 0; >> -    destroy_session = &vcrypto->ctrl.u.destroy_session; >> +    destroy_session = &vc_ctrl_req->ctrl.u.destroy_session; >>       if (encrypt) >>           destroy_session->session_id = >> @@ -229,37 +224,33 @@ static int >> virtio_crypto_alg_skcipher_close_session( >>           destroy_session->session_id = >>               cpu_to_le64(ctx->dec_sess_info.session_id); >> -    sg_init_one(&outhdr, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); >> +    sg_init_one(&outhdr, &vc_ctrl_req->ctrl, sizeof(vc_ctrl_req->ctrl)); >>       sgs[num_out++] = &outhdr; >>       /* Return status and session id back */ >> -    sg_init_one(&status_sg, &vcrypto->ctrl_status.status, >> -        sizeof(vcrypto->ctrl_status.status)); >> +    vc_ctrl_req->ctrl_status.status = VIRTIO_CRYPTO_ERR; >> +    sg_init_one(&status_sg, &vc_ctrl_req->ctrl_status.status, >> +        sizeof(vc_ctrl_req->ctrl_status.status)); >>       sgs[num_out + num_in++] = &status_sg; >> -    err = virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, >> -            num_in, vcrypto, GFP_ATOMIC); >> -    if (err < 0) { >> -        spin_unlock(&vcrypto->ctrl_lock); >> -        return err; >> -    } >> -    virtqueue_kick(vcrypto->ctrl_vq); >> - >> -    while (!virtqueue_get_buf(vcrypto->ctrl_vq, &tmp) && >> -           !virtqueue_is_broken(vcrypto->ctrl_vq)) >> -        cpu_relax(); >> +    err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, >> num_in, vc_ctrl_req); >> +    if (err < 0) >> +        goto out; >> -    if (vcrypto->ctrl_status.status != VIRTIO_CRYPTO_OK) { >> -        spin_unlock(&vcrypto->ctrl_lock); >> +    if (vc_ctrl_req->ctrl_status.status != VIRTIO_CRYPTO_OK) { >>           pr_err("virtio_crypto: Close session failed status: %u, >> session_id: 0x%llx\n", >> -            vcrypto->ctrl_status.status, >> +            vc_ctrl_req->ctrl_status.status, >>               destroy_session->session_id); >> -        return -EINVAL; >> +        err = -EINVAL; >> +        goto out; >>       } >> -    spin_unlock(&vcrypto->ctrl_lock); >> -    return 0; >> +    err = 0; >> +out: >> +    kfree(vc_ctrl_req); >> + >> +    return err; >>   } >>   static int virtio_crypto_alg_skcipher_init_sessions( > -- zhenwei pi